From be79db3139be14466b753cf41a58029632e0afd1 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Tue, 12 Dec 2023 10:12:54 +0100 Subject: [PATCH 01/23] tests: unit: conftest: Move the env_variables fixture to gomod At the same time, make this a 'module' scoped fixture. Signed-off-by: Erik Skultety --- tests/unit/package_managers/conftest.py | 9 --------- tests/unit/package_managers/test_gomod.py | 9 +++++++++ 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/tests/unit/package_managers/conftest.py b/tests/unit/package_managers/conftest.py index 06b3c634d..e9e43d903 100644 --- a/tests/unit/package_managers/conftest.py +++ b/tests/unit/package_managers/conftest.py @@ -204,15 +204,6 @@ def fake_repo() -> Generator[tuple[Union[str, bytes], Union[str, bytes]], Any, N yield repo_dir, repo_dir.lstrip("/") -@pytest.fixture() -def env_variables() -> list[dict[str, str]]: - return [ - {"name": "GOCACHE", "value": "deps/gomod", "kind": "path"}, - {"name": "GOMODCACHE", "value": "deps/gomod/pkg/mod", "kind": "path"}, - {"name": "GOPATH", "value": "deps/gomod", "kind": "path"}, - ] - - @pytest.fixture def rooted_tmp_path(tmp_path: Path) -> RootedPath: return RootedPath(tmp_path) diff --git a/tests/unit/package_managers/test_gomod.py b/tests/unit/package_managers/test_gomod.py index e5d181279..2f2b309db 100644 --- a/tests/unit/package_managers/test_gomod.py +++ b/tests/unit/package_managers/test_gomod.py @@ -52,6 +52,15 @@ def setup_module() -> None: gomod.log.setLevel("DEBUG") +@pytest.fixture(scope="module") +def env_variables() -> list[dict[str, str]]: + return [ + {"name": "GOCACHE", "value": "deps/gomod", "kind": "path"}, + {"name": "GOMODCACHE", "value": "deps/gomod/pkg/mod", "kind": "path"}, + {"name": "GOPATH", "value": "deps/gomod", "kind": "path"}, + ] + + @pytest.fixture(scope="module", autouse=True) def mock_which_go() -> Iterator[None]: """Make shutil.which return GO_CMD_PATH for all the tests in this file. From cd2faca30df0b198bbe22cf523e9213709de91b2 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Wed, 17 Jan 2024 11:49:43 +0100 Subject: [PATCH 02/23] tox: Limit flake8 to cachi2 and tests directories only Found this issue by a chance having some random untracked directory containing Python code in the repository. Signed-off-by: Erik Skultety --- tox.ini | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tox.ini b/tox.ini index 5c4005d0d..887b05586 100644 --- a/tox.ini +++ b/tox.ini @@ -33,7 +33,7 @@ commands_post = [testenv:flake8] skip_install = true commands = - flake8 + flake8 cachi2 tests utils [testenv:bandit] skip_install = true From 45f1f717fea3317d3fad9a99728c02be69e6bc93 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Fri, 12 Jan 2024 10:41:14 +0100 Subject: [PATCH 03/23] package_managers: gomod: Drop the git.objects import We're already importing the whole git namespace, so we shouldn't need to import another package. Signed-off-by: Erik Skultety --- cachi2/core/package_managers/gomod.py | 1 - 1 file changed, 1 deletion(-) diff --git a/cachi2/core/package_managers/gomod.py b/cachi2/core/package_managers/gomod.py index 1e9b76e39..06ba74912 100644 --- a/cachi2/core/package_managers/gomod.py +++ b/cachi2/core/package_managers/gomod.py @@ -27,7 +27,6 @@ import backoff import git -import git.objects import pydantic import semver from packageurl import PackageURL From 0580aac2645c1753512d2130cb561eb3d55ec716 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Fri, 12 Jan 2024 10:42:43 +0100 Subject: [PATCH 04/23] package_managers: gomod: Don't use cachito for any filenames/prefixes This is clearly a remnant from the old service and needs to be renamed to cachi2. Signed-off-by: Erik Skultety --- cachi2/core/package_managers/gomod.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cachi2/core/package_managers/gomod.py b/cachi2/core/package_managers/gomod.py index 06ba74912..e96b0d590 100644 --- a/cachi2/core/package_managers/gomod.py +++ b/cachi2/core/package_managers/gomod.py @@ -382,7 +382,7 @@ def fetch_gomod_source(request: Request) -> RequestOutput: repo_name = _get_repository_name(request.source_dir) version_resolver = ModuleVersionResolver.from_repo_path(request.source_dir) - with GoCacheTemporaryDirectory(prefix="cachito-") as tmp_dir: + with GoCacheTemporaryDirectory(prefix="cachi2-") as tmp_dir: request.gomod_download_dir.path.mkdir(exist_ok=True, parents=True) for subpath in subpaths: log.info("Fetching the gomod dependencies at subpath %s", subpath) From b9a2d0e4520310c9ae3ec944d9d044d7e625ca7c Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Fri, 12 Jan 2024 10:43:53 +0100 Subject: [PATCH 05/23] core: utils: Introduce get_cache_dir helper Whenever we need to save some downloaded data persistently for repeated use, let's use a proper cache directory for that, defaulting to $XDG_CACHE_HOME. Signed-off-by: Erik Skultety --- cachi2/core/utils.py | 10 ++++++++++ tests/unit/test_utils.py | 22 +++++++++++++++++++++- 2 files changed, 31 insertions(+), 1 deletion(-) diff --git a/cachi2/core/utils.py b/cachi2/core/utils.py index b967d921d..c8cd81173 100644 --- a/cachi2/core/utils.py +++ b/cachi2/core/utils.py @@ -1,5 +1,6 @@ import json import logging +import os import re import shutil import subprocess # nosec @@ -111,3 +112,12 @@ def _copy_using(copy_function: Callable) -> None: _copy_using(shutil.copy2) return destination + + +def get_cache_dir() -> Path: + """Return cachi2's global cache directory, useful for storing reusable data.""" + try: + cache_dir = Path(os.environ["XDG_CACHE_HOME"]) + except KeyError: + cache_dir = Path.home().joinpath(".cache") + return cache_dir.joinpath("cachi2") diff --git a/tests/unit/test_utils.py b/tests/unit/test_utils.py index 57e9ea7ae..c1cc9c807 100644 --- a/tests/unit/test_utils.py +++ b/tests/unit/test_utils.py @@ -8,7 +8,7 @@ import reflink # type: ignore from cachi2.core.errors import Cachi2Error -from cachi2.core.utils import copy_directory, run_cmd +from cachi2.core.utils import copy_directory, get_cache_dir, run_cmd @mock.patch("subprocess.run") @@ -132,3 +132,23 @@ def test_copy_directory_fallback_on_reflink_fail( # check we called both copy_functions (reflink, copy2) mock_reflink.assert_called_once() mock_shutil_copy2.assert_called_once() + + +@pytest.mark.parametrize("environ", [{"XDG_CACHE_HOME": "/tmp/xdg_home/"}, {}]) +@mock.patch("pathlib.Path.home") +@mock.patch("os.environ") +def test_get_cache_dir( + mock_environ: mock.MagicMock, + mock_home_path: mock.Mock, + environ: dict, + tmp_path: Path, +) -> None: + mock_environ.__getitem__.side_effect = environ.__getitem__ + mock_home_path.return_value = tmp_path + + if environ: + expected = Path(environ["XDG_CACHE_HOME"], "cachi2") + else: + expected = Path(tmp_path, ".cache/cachi2") + + assert get_cache_dir() == expected From f57f7f31e83445f71927aa4feb0003be7d6cb025 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Fri, 12 Jan 2024 10:45:49 +0100 Subject: [PATCH 06/23] package_managers: gomod: Introduce Go toolchain wrapping class This patch introduces a skeleton interface to what will ultimately become the go CLI command wrapping class for all of the module logic. Signed-off-by: Erik Skultety --- cachi2/core/package_managers/gomod.py | 48 +++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/cachi2/core/package_managers/gomod.py b/cachi2/core/package_managers/gomod.py index e96b0d590..16c4a8eec 100644 --- a/cachi2/core/package_managers/gomod.py +++ b/cachi2/core/package_managers/gomod.py @@ -30,6 +30,7 @@ import pydantic import semver from packageurl import PackageURL +from packaging import version if TYPE_CHECKING: from typing_extensions import Self @@ -212,6 +213,53 @@ def to_component(self) -> Component: return Component(name=self.name, purl=self.purl) +# NOTE: Skim the class once we don't need to work with multiple versions of Go +class Go: + """High level wrapper over the 'go' CLI command. + + Provides convenient methods to download project dependencies, alternative toolchains, + parses various Go files, etc. + """ + + def __init__( + self, + binary: Union[str, os.PathLike[str]] = "go", + release: Optional[str] = None, + ) -> None: + """Initialize the Go toolchain wrapper. + + :param binary: path-like string to the Go binary or direct command (in PATH) + :param release: Go release version string, e.g. go1.20, go1.21.10 + :returns: a callable instance + """ + # run_cmd will take care of checking any bogus passed in 'binary' + self._bin = str(binary) + self._release = release + + self._version: Optional[version.Version] = None + self._install_toolchain: bool = False + + def __call__(self, cmd: list[str], params: Optional[dict] = None, retry: bool = False) -> str: # type: ignore + """Run a Go command using the underlying toolchain, same as running GoToolchain()(). + + :param cmd: Go CLI options + :param params: additional subprocess arguments, e.g. 'env' + :param retry: whether the command should be retried on failure (e.g. network actions) + :returs: Go command's output + """ + pass + + @property + def version(self) -> version.Version: # type: ignore + """Version of the Go toolchain as a packaging.version.Version object.""" + pass + + @property + def release(self) -> str: # type: ignore + """Release name of the Go Toolchain, e.g. go1.20 .""" + pass + + ModuleID = tuple[str, str] From 7afd263af8b3eeec1c284dc02950aaf8bb9131b1 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Tue, 16 Jan 2024 15:02:34 +0100 Subject: [PATCH 07/23] package_managers: gomod: Go: Implement an internal _run method This is essentially a copy-paste of the existing _run_gomod_cmd function which it should ultimately replace when we switch the whole module to the Go instance interface. There are only 3 notable differences compared to the original: - use of the more common **kwargs pattern to abstract any subprocess.run arguments properly and make them transparent to the caller - forcing the type of 'cmd' from a Sequence to list (it's going to be more handy with future patches) - making the error message more generic tied towards the actual Go command execution rather than tying it strictly to downloading dependencies Signed-off-by: Erik Skultety --- cachi2/core/package_managers/gomod.py | 10 +++++++ tests/unit/package_managers/test_gomod.py | 36 +++++++++++++++++++++++ 2 files changed, 46 insertions(+) diff --git a/cachi2/core/package_managers/gomod.py b/cachi2/core/package_managers/gomod.py index 16c4a8eec..eed77be52 100644 --- a/cachi2/core/package_managers/gomod.py +++ b/cachi2/core/package_managers/gomod.py @@ -259,6 +259,16 @@ def release(self) -> str: # type: ignore """Release name of the Go Toolchain, e.g. go1.20 .""" pass + def _run(self, cmd: list[str], **kwargs: Any) -> str: + try: + log.debug(f"Running '{cmd}'") + return run_cmd(cmd, kwargs) + except subprocess.CalledProcessError as e: + rc = e.returncode + raise PackageManagerError( + f"Go execution failed: `{' '.join(cmd)}` failed with {rc=}" + ) from e + ModuleID = tuple[str, str] diff --git a/tests/unit/package_managers/test_gomod.py b/tests/unit/package_managers/test_gomod.py index 2f2b309db..4b282a9ac 100644 --- a/tests/unit/package_managers/test_gomod.py +++ b/tests/unit/package_managers/test_gomod.py @@ -18,6 +18,7 @@ from cachi2.core.models.sbom import Component, Property from cachi2.core.package_managers import gomod from cachi2.core.package_managers.gomod import ( + Go, Module, ModuleID, ModuleVersionResolver, @@ -1588,3 +1589,38 @@ def test_fetch_tags_fail(repo_remote_with_tag: tuple[RootedPath, RootedPath]) -> ) with pytest.raises(FetchError, match=error_msg): ModuleVersionResolver.from_repo_path(remote_repo_path) + + +class TestGo: + @pytest.mark.parametrize( + "bin_, params", + [ + pytest.param(None, {}, id="bundled_go_no_params"), + pytest.param("/usr/bin/go1.21", {}, id="custom_go_no_params"), + pytest.param(None, {"cwd": "/foo/bar"}, id="bundled_go_params"), + pytest.param( + "/usr/bin/go1.21", + { + "env": {"GOCACHE": "/foo", "GOTOOLCHAIN": "local"}, + "cwd": "/foo/bar", + "text": True, + }, + id="custom_go_params", + ), + ], + ) + @mock.patch("cachi2.core.package_managers.gomod.run_cmd") + def test_run( + self, + mock_run: mock.Mock, + bin_: str, + params: dict, + ) -> None: + if not bin_: + go = Go(bin_) + else: + go = Go() + + cmd = [go._bin, "mod", "download"] + go._run(cmd, **params) + mock_run.assert_called_once_with(cmd, params) From a22c83bf6a3d275fa56e63afe729736e0717bcbc Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Tue, 16 Jan 2024 15:02:34 +0100 Subject: [PATCH 08/23] package_managers: gomod: Go: Implement an internal _retry method This is essentially a copy-paste of the existing _run_download_cmd function which it should ultimately replace when we switch the whole module to the Go instance interface. There are only 3 notable differences compared to the original: - use of the more common **kwargs pattern to abstract any subprocess.run arguments properly and make them transparent to the caller - forcing the type of 'cmd' from a Sequence to list (it's going to be more handy with future patches) - making the error message more generic tied towards the actual Go command execution rather than tying it strictly to downloading dependencies Signed-off-by: Erik Skultety --- cachi2/core/package_managers/gomod.py | 32 +++++++++ tests/unit/package_managers/test_gomod.py | 80 +++++++++++++++++++++++ 2 files changed, 112 insertions(+) diff --git a/cachi2/core/package_managers/gomod.py b/cachi2/core/package_managers/gomod.py index eed77be52..2af3916f6 100644 --- a/cachi2/core/package_managers/gomod.py +++ b/cachi2/core/package_managers/gomod.py @@ -259,6 +259,38 @@ def release(self) -> str: # type: ignore """Release name of the Go Toolchain, e.g. go1.20 .""" pass + def _retry(self, cmd: list[str], **kwargs: Any) -> str: + """Run gomod command in a networking context. + + Commands that involve networking, such as dependency downloads, may fail due to network + errors (go is bad at retrying), so the entire operation will be retried a configurable + number of times. + + The same cache directory will be use between retries, so Go will not have to download the + same artifact (e.g. dependency) twice. The backoff is exponential, Cachi2 will wait 1s -> + 2s -> 4s -> ... before retrying. + """ + n_tries = get_config().gomod_download_max_tries + + @backoff.on_exception( + backoff.expo, + PackageManagerError, + jitter=None, # use deterministic backoff, do not apply jitter + max_tries=n_tries, + logger=log, + ) + def run_go(_cmd: list[str], **kwargs: Any) -> str: + return self._run(_cmd, **kwargs) + + try: + return run_go(cmd, **kwargs) + except PackageManagerError: + err_msg = ( + f"Go execution failed: Cachi2 re-tried running `{' '.join(cmd)}` command " + f"{n_tries} times." + ) + raise PackageManagerError(err_msg) from None + def _run(self, cmd: list[str], **kwargs: Any) -> str: try: log.debug(f"Running '{cmd}'") diff --git a/tests/unit/package_managers/test_gomod.py b/tests/unit/package_managers/test_gomod.py index 4b282a9ac..42f587d1f 100644 --- a/tests/unit/package_managers/test_gomod.py +++ b/tests/unit/package_managers/test_gomod.py @@ -1624,3 +1624,83 @@ def test_run( cmd = [go._bin, "mod", "download"] go._run(cmd, **params) mock_run.assert_called_once_with(cmd, params) + + @pytest.mark.parametrize( + "bin_, params, tries_needed", + [ + pytest.param(None, {}, 1, id="bundled_go_1_try"), + pytest.param("/usr/bin/go1.21", {}, 2, id="custom_go_2_tries"), + pytest.param( + None, + { + "env": {"GOCACHE": "/foo", "GOTOOLCHAIN": "local"}, + "cwd": "/foo/bar", + "text": True, + }, + 5, + id="bundled_go_params_5_tries", + ), + ], + ) + @mock.patch("cachi2.core.package_managers.gomod.get_config") + @mock.patch("cachi2.core.package_managers.gomod.run_cmd") + @mock.patch("time.sleep") + def test_retry( + self, + mock_sleep: mock.Mock, + mock_run: mock.Mock, + mock_config: mock.Mock, + bin_: str, + params: dict, + tries_needed: int, + caplog: pytest.LogCaptureFixture, + ) -> None: + mock_config.return_value.gomod_download_max_tries = 5 + + # We don't want to mock subprocess.run here, because: + # 1) the call chain looks like this: Go()._retry->run_go->self._run->run_cmd->subprocess.run + # 2) we wouldn't be able to check if params are propagated correctly since run_cmd adds some too + failure = subprocess.CalledProcessError(returncode=1, cmd="foo") + success = 1 + mock_run.side_effect = [failure for _ in range(tries_needed - 1)] + [success] + + if bin_: + go = Go(bin_) + else: + go = Go() + + cmd = [go._bin, "mod", "download"] + go._retry(cmd, **params) + mock_run.assert_called_with(cmd, params) + assert mock_run.call_count == tries_needed + assert mock_sleep.call_count == tries_needed - 1 + + for n in range(tries_needed - 1): + wait = 2**n + assert f"Backing off run_go(...) for {wait:.1f}s" in caplog.text + + @mock.patch("cachi2.core.package_managers.gomod.get_config") + @mock.patch("cachi2.core.package_managers.gomod.run_cmd") + @mock.patch("time.sleep") + def test_retry_failure( + self, mock_sleep: Any, mock_run: Any, mock_config: Any, caplog: pytest.LogCaptureFixture + ) -> None: + mock_config.return_value.gomod_download_max_tries = 5 + + failure = subprocess.CalledProcessError(returncode=1, cmd="foo") + mock_run.side_effect = [failure] * 5 + go = Go() + + error_msg = f"Go execution failed: Cachi2 re-tried running `{go._bin} mod download` command 5 times." + + with pytest.raises(PackageManagerError, match=error_msg): + go._retry([go._bin, "mod", "download"]) + + assert mock_run.call_count == 5 + assert mock_sleep.call_count == 4 + + assert "Backing off run_go(...) for 1.0s" in caplog.text + assert "Backing off run_go(...) for 2.0s" in caplog.text + assert "Backing off run_go(...) for 4.0s" in caplog.text + assert "Backing off run_go(...) for 8.0s" in caplog.text + assert "Giving up run_go(...) after 5 tries" in caplog.text From 97c2c24c9460144a7ad98bcff5957a34ba641e13 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Tue, 16 Jan 2024 15:11:57 +0100 Subject: [PATCH 09/23] package_managers: gomod: Go: Implement an internal _install method This helper will take care of downloading and installing an alternative version of Go SDK (including the toolchain) if needed. This is supposed to take care of cases where: - our base Go installation >= 1.21, but we need an older e.g. 1.19 - our base Go installation < 1.21, but we need to compile with 1.21 Signed-off-by: Erik Skultety --- cachi2/core/package_managers/gomod.py | 50 ++++++++++++++++++++++- tests/unit/package_managers/test_gomod.py | 35 ++++++++++++++++ 2 files changed, 84 insertions(+), 1 deletion(-) diff --git a/cachi2/core/package_managers/gomod.py b/cachi2/core/package_managers/gomod.py index 2af3916f6..01c989950 100644 --- a/cachi2/core/package_managers/gomod.py +++ b/cachi2/core/package_managers/gomod.py @@ -43,7 +43,7 @@ from cachi2.core.models.sbom import Component from cachi2.core.rooted_path import PathOutsideRoot, RootedPath from cachi2.core.scm import get_repo_id -from cachi2.core.utils import load_json_stream, run_cmd +from cachi2.core.utils import get_cache_dir, load_json_stream, run_cmd log = logging.getLogger(__name__) @@ -259,6 +259,54 @@ def release(self) -> str: # type: ignore """Release name of the Go Toolchain, e.g. go1.20 .""" pass + def _install(self, release: str) -> str: + """Fetch and install an alternative version of main Go toolchain. + + This method should only ever be needed on local cachi2 installs, but not in container + environment installs where we pre-install multiple Go versions. + Because Go can't really be told where the toolchain should be installed to, the process is + as follows: + 1) we use the base Go toolchain to fetch a versioned toolchain shim to a temporary + directory as we're going to dispose of the shim later + 2) we use the downloaded shim to actually fetch the whole SDK for the desired version + of Go toolchain + 3) we move the installed SDK to cachi2's cache directory + (i.e. $HOME/.cache/cachi2/go/) to reuse the toolchains in subsequent runs + 4) we delete the downloaded shim as we're not going to execute the toolchain through + that any longer + 5) we delete any build artifacts go created as part of downloading the SDK as those + can occupy >~70MB of storage + + :param release: Go release version string, e.g. go1.20, go1.21.10 + :param env: params to use with the underlying subprocess and 'go' execution + :returns: path-like string to the newly installed toolchain binary + """ + base_url = "golang.org/dl/" + url = f"{base_url}{release}@latest" + + # Download the go shim to a temporary directory and wipe it after we're done + # Go would download the shim to $HOME too, but unlike 'go download' we can at least adjust + # 'go install' to point elsewhere using $GOPATH + with tempfile.TemporaryDirectory(prefix="cachi2", suffix="go-download") as td: + log.debug(f"Installing Go {release} toolchain shim from '{url}'") + env = { + "PATH": os.environ.get("PATH", ""), + "GOPATH": td, + "GOCACHE": str(Path(td, "cache")), + } + self._retry([self._bin, "install", url], env=env) + + log.debug(f"Downloading Go {release} SDK") + self._retry([f"{td}/bin/{release}", "download"], env=env) + + # move the newly downloaded SDK from $HOME/sdk to $HOME/.cache/cachi2/go + sdk_download_dir = Path.home() / f"sdk/{release}" + cachi2_go_dest_dir = get_cache_dir() / "go" / release + shutil.move(sdk_download_dir, cachi2_go_dest_dir) + + log.debug(f"Go {release} toolchain installed at: {cachi2_go_dest_dir}") + return str(cachi2_go_dest_dir / "bin/go") + def _retry(self, cmd: list[str], **kwargs: Any) -> str: """Run gomod command in a networking context. diff --git a/tests/unit/package_managers/test_gomod.py b/tests/unit/package_managers/test_gomod.py index 42f587d1f..770e4c5f9 100644 --- a/tests/unit/package_managers/test_gomod.py +++ b/tests/unit/package_managers/test_gomod.py @@ -1704,3 +1704,38 @@ def test_retry_failure( assert "Backing off run_go(...) for 4.0s" in caplog.text assert "Backing off run_go(...) for 8.0s" in caplog.text assert "Giving up run_go(...) after 5 tries" in caplog.text + + @pytest.mark.parametrize("release", ["go1.20", "go1.21.1"]) + @mock.patch("pathlib.Path.home") + @mock.patch("cachi2.core.package_managers.gomod.Go._retry") + @mock.patch("cachi2.core.package_managers.gomod.get_cache_dir") + def test_install( + self, + mock_cache_dir: mock.Mock, + mock_go_retry: mock.Mock, + mock_path_home: mock.Mock, + tmp_path: Path, + release: str, + ) -> None: + dest_cache_dir = tmp_path / "cache" + env_vars = ["PATH", "GOPATH", "GOCACHE"] + + mock_cache_dir.return_value = dest_cache_dir + mock_go_retry.return_value = 0 + mock_path_home.return_value = tmp_path + + sdk_download_dir = tmp_path / f"sdk/{release}" + sdk_bin_dir = sdk_download_dir / "bin" + sdk_bin_dir.mkdir(parents=True) + sdk_bin_dir.joinpath("go").touch() + + go = Go(release=release) + binary = Path(go._install(release)) + assert mock_go_retry.call_args_list[0][0][0][1] == "install" + assert mock_go_retry.call_args_list[0][0][0][2] == f"golang.org/dl/{release}@latest" + assert mock_go_retry.call_args_list[0][1].get("env") is not None + assert set(mock_go_retry.call_args_list[0][1]["env"].keys()) & set(env_vars) + assert not sdk_download_dir.exists() + assert dest_cache_dir.exists() + assert binary.exists() + assert str(binary) == f"{dest_cache_dir}/go/{release}/bin/go" From 8859b8603ac8af605c4d36b80c37845c2a474017 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Tue, 16 Jan 2024 15:28:45 +0100 Subject: [PATCH 10/23] package_managers: gomod: Go: Implement the __call__ method To make the whole Go CLI wrapper interface more convenient, make instances of the class callables, so that one can just write something like: go(["foo", "bar"], env={}, capture_output=False) So in the end it's supposed to make the usage more intuitive by: - passing any CLI arguments to a callable named "go" - passing subprocess arguments directly with the base signature Signed-off-by: Erik Skultety --- cachi2/core/package_managers/gomod.py | 16 +++++- tests/unit/package_managers/test_gomod.py | 69 +++++++++++++++++++++++ 2 files changed, 83 insertions(+), 2 deletions(-) diff --git a/cachi2/core/package_managers/gomod.py b/cachi2/core/package_managers/gomod.py index 01c989950..cda887fc9 100644 --- a/cachi2/core/package_managers/gomod.py +++ b/cachi2/core/package_managers/gomod.py @@ -239,7 +239,7 @@ def __init__( self._version: Optional[version.Version] = None self._install_toolchain: bool = False - def __call__(self, cmd: list[str], params: Optional[dict] = None, retry: bool = False) -> str: # type: ignore + def __call__(self, cmd: list[str], params: Optional[dict] = None, retry: bool = False) -> str: """Run a Go command using the underlying toolchain, same as running GoToolchain()(). :param cmd: Go CLI options @@ -247,7 +247,19 @@ def __call__(self, cmd: list[str], params: Optional[dict] = None, retry: bool = :param retry: whether the command should be retried on failure (e.g. network actions) :returs: Go command's output """ - pass + if params is None: + params = {} + + # we check both values to silence the type checker complaining self._release might be None + if self._install_toolchain and self._release: + self._bin = self._install(self._release) + self._install_toolchain = False + + cmd = [self._bin] + cmd + if retry: + return self._retry(cmd, **params) + + return self._run(cmd, **params) @property def version(self) -> version.Version: # type: ignore diff --git a/tests/unit/package_managers/test_gomod.py b/tests/unit/package_managers/test_gomod.py index 770e4c5f9..e34b8c240 100644 --- a/tests/unit/package_managers/test_gomod.py +++ b/tests/unit/package_managers/test_gomod.py @@ -1739,3 +1739,72 @@ def test_install( assert dest_cache_dir.exists() assert binary.exists() assert str(binary) == f"{dest_cache_dir}/go/{release}/bin/go" + + @pytest.mark.parametrize( + "release, needs_install, retry", + [ + pytest.param(None, False, False, id="bundled_go"), + pytest.param("go1.20", False, True, id="custom_release_installed"), + pytest.param("go1.21.0", True, True, id="custom_release_needs_installation"), + ], + ) + @mock.patch("cachi2.core.package_managers.gomod.get_config") + @mock.patch("cachi2.core.package_managers.gomod.Go._install") + @mock.patch("cachi2.core.package_managers.gomod.Go._run") + def test_call( + self, + mock_run: mock.Mock, + mock_install: mock.Mock, + mock_get_config: mock.Mock, + tmp_path: Path, + release: Optional[str], + needs_install: bool, + retry: bool, + ) -> None: + go_bin = tmp_path / f"go/{release}/bin/go" + mock_install.return_value = go_bin.as_posix() + + env = {"env": {"GOTOOLCHAIN": "local", "GOCACHE": "foo", "GOPATH": "bar"}} + opts = ["mod", "download"] + go = Go(release=release) + go._install_toolchain = needs_install + go(opts, retry=retry, params=env) + + cmd = [go._bin, *opts] + if not retry: + mock_run.assert_called_once_with(cmd, **env) + else: + mock_get_config.return_value.gomod_download_max_tries = 1 + mock_run.call_count = 1 + mock_run.assert_called_with(cmd, **env) + + if needs_install: + assert go._install_toolchain is False + + @pytest.mark.parametrize("retry", [False, True]) + @mock.patch("cachi2.core.package_managers.gomod.get_config") + @mock.patch("subprocess.run") + def test_call_failure( + self, + mock_run: mock.Mock, + mock_get_config: mock.Mock, + retry: bool, + ) -> None: + tries = 1 + mock_get_config.return_value.gomod_download_max_tries = tries + failure = proc_mock(returncode=1, stdout="") + mock_run.side_effect = [failure] + + opts = ["mod", "download"] + cmd = ["go", *opts] + error_msg = "Go execution failed: " + if retry: + error_msg += f"Cachi2 re-tried running `{' '.join(cmd)}` command {tries} times." + else: + error_msg += f"`{' '.join(cmd)}` failed with rc=1" + + with pytest.raises(PackageManagerError, match=error_msg): + go = Go() + go(opts, retry=retry) + + assert mock_run.call_count == 1 From 3c3a5b16aa409c9e7888fa8677b10f2b6b524ce9 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Tue, 16 Jan 2024 15:26:05 +0100 Subject: [PATCH 11/23] package_managers: gomod: Go: Implement _locate_toolchain helper This helper's purpose is to locate an alternative toolchain installation if requested. It scans 2 locations: 1) system /usr/local/go/go - this one will be pre-installed in the container image to save time during runtime 2) $XDG_CACHE_HOME/cachi2/go - this one is targeted at local cachi2 use cases, i.e. without using the container image Signed-off-by: Erik Skultety --- cachi2/core/package_managers/gomod.py | 23 ++++++++++ tests/unit/package_managers/test_gomod.py | 56 ++++++++++++++++++++++- 2 files changed, 77 insertions(+), 2 deletions(-) diff --git a/cachi2/core/package_managers/gomod.py b/cachi2/core/package_managers/gomod.py index cda887fc9..e9af0788a 100644 --- a/cachi2/core/package_managers/gomod.py +++ b/cachi2/core/package_managers/gomod.py @@ -239,6 +239,12 @@ def __init__( self._version: Optional[version.Version] = None self._install_toolchain: bool = False + if self._release: + if bin_ := self._locate_toolchain(self._release): + self._bin = bin_ + else: + self._install_toolchain = True + def __call__(self, cmd: list[str], params: Optional[dict] = None, retry: bool = False) -> str: """Run a Go command using the underlying toolchain, same as running GoToolchain()(). @@ -271,6 +277,23 @@ def release(self) -> str: # type: ignore """Release name of the Go Toolchain, e.g. go1.20 .""" pass + @staticmethod + def _locate_toolchain(release: str) -> Optional[str]: + """Given a release locate an alternative Go toolchain. + + Locate an alternative Go toolchain under the one of the following locations: + - /usr/local/go/ for container environments (pre-installed) + - $XDG_CACHE_HOME/cachi2/go for local environments (download & cache) + """ + local_cache = get_cache_dir() + go_path_stub = f"go/{release}/bin/go" + for p in [Path("/usr/local/", go_path_stub), Path(local_cache, go_path_stub)]: + log.debug(f"Trying to locate Go toolchain at '{p}'") + if p.exists(): + return str(p) + + return None + def _install(self, release: str) -> str: """Fetch and install an alternative version of main Go toolchain. diff --git a/tests/unit/package_managers/test_gomod.py b/tests/unit/package_managers/test_gomod.py index e34b8c240..d42a7c4cc 100644 --- a/tests/unit/package_managers/test_gomod.py +++ b/tests/unit/package_managers/test_gomod.py @@ -1749,12 +1749,14 @@ def test_install( ], ) @mock.patch("cachi2.core.package_managers.gomod.get_config") + @mock.patch("cachi2.core.package_managers.gomod.Go._locate_toolchain") @mock.patch("cachi2.core.package_managers.gomod.Go._install") @mock.patch("cachi2.core.package_managers.gomod.Go._run") def test_call( self, mock_run: mock.Mock, mock_install: mock.Mock, + mock_locate_toolchain: mock.Mock, mock_get_config: mock.Mock, tmp_path: Path, release: Optional[str], @@ -1762,12 +1764,16 @@ def test_call( retry: bool, ) -> None: go_bin = tmp_path / f"go/{release}/bin/go" - mock_install.return_value = go_bin.as_posix() + + if not needs_install: + mock_locate_toolchain.return_value = go_bin.as_posix() + else: + mock_locate_toolchain.return_value = None + mock_install.return_value = go_bin.as_posix() env = {"env": {"GOTOOLCHAIN": "local", "GOCACHE": "foo", "GOPATH": "bar"}} opts = ["mod", "download"] go = Go(release=release) - go._install_toolchain = needs_install go(opts, retry=retry, params=env) cmd = [go._bin, *opts] @@ -1808,3 +1814,49 @@ def test_call_failure( go(opts, retry=retry) assert mock_run.call_count == 1 + + @pytest.mark.parametrize( + "base_path", + [ + pytest.param("usr/local", id="locate_in_system_path"), + pytest.param("cachi2", id="locate_in_XDG_CACHE_HOME"), + ], + ) + @mock.patch("cachi2.core.package_managers.gomod.get_cache_dir") + @mock.patch("cachi2.core.package_managers.gomod.Path") + def test_locate_toolchain( + self, mock_path: mock.Mock, mock_cache_dir: mock.Mock, tmp_path: Path, base_path: str + ) -> None: + def prefix_path(*args: Any) -> Path: + # we have to mock Path creation to prevent tests touching real system paths + + my_args = list(args) + if str(tmp_path) not in my_args[0] and my_args[0].startswith("/"): + my_args[0] = my_args[0][1:] + return Path(tmp_path, *my_args) + + mock_path.side_effect = prefix_path + mock_cache_dir.return_value = "cachi2" + + release = "go1.20" + go_bin_dir = tmp_path / f"{base_path}/go/{release}/bin" + go_bin_dir.mkdir(parents=True) + go_bin_dir.joinpath("go").touch() + + go = Go(release=release) + + assert Path(go._bin) == go_bin_dir / "go" + assert go._install_toolchain is False + + @mock.patch("cachi2.core.package_managers.gomod.get_cache_dir") + def test_locate_toolchain_failure( + self, + mock_cache_dir: mock.Mock, + ) -> None: + mock_cache_dir.return_value = "cachi2" + + release = "go1.20" + go = Go(release=release) + + assert go._bin == "go" + assert go._install_toolchain is True From 5f09a41dd2ade244590985afbb1d84241fdb9983 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Tue, 16 Jan 2024 15:27:13 +0100 Subject: [PATCH 12/23] package_managers: gomod: Go: Implement release property The release property is essentially just a gateway to extracting the version number. It uses and parses 'go version' to get the information. Signed-off-by: Erik Skultety --- cachi2/core/package_managers/gomod.py | 21 +++++++++++-- tests/unit/package_managers/test_gomod.py | 37 +++++++++++++++++++++++ 2 files changed, 56 insertions(+), 2 deletions(-) diff --git a/cachi2/core/package_managers/gomod.py b/cachi2/core/package_managers/gomod.py index e9af0788a..9225ac5df 100644 --- a/cachi2/core/package_managers/gomod.py +++ b/cachi2/core/package_managers/gomod.py @@ -273,9 +273,26 @@ def version(self) -> version.Version: # type: ignore pass @property - def release(self) -> str: # type: ignore + def release(self) -> str: """Release name of the Go Toolchain, e.g. go1.20 .""" - pass + # lazy evaluation: defer running 'go' + if not self._release: + output = self(["version"]) + log.info(f"Go release: {output}") + release_pattern = f"go{version.VERSION_PATTERN}" + + # packaging.version requires passing the re.VERBOSE|re.IGNORECASE flags [1] + # [1] https://packaging.pypa.io/en/latest/version.html#packaging.version.VERSION_PATTERN + if match := re.search(release_pattern, output, re.VERBOSE | re.IGNORECASE): + self._release = match.group(0) + else: + # This should not happen, otherwise we must figure out a more reliable way of + # extracting Go version + raise PackageManagerError( + f"Could not extract Go toolchain version from Go's output: '{output}'", + solution="This is a fatal error, please open a bug report against cachi2", + ) + return self._release @staticmethod def _locate_toolchain(release: str) -> Optional[str]: diff --git a/tests/unit/package_managers/test_gomod.py b/tests/unit/package_managers/test_gomod.py index d42a7c4cc..6cb319c0b 100644 --- a/tests/unit/package_managers/test_gomod.py +++ b/tests/unit/package_managers/test_gomod.py @@ -1860,3 +1860,40 @@ def test_locate_toolchain_failure( assert go._bin == "go" assert go._install_toolchain is True + + @pytest.mark.parametrize( + "release, expect, go_output", + [ + pytest.param("go1.20", "go1.20", None, id="explicit_release"), + pytest.param( + None, "go1.21.4", "go version go1.21.4 linux/amd64", id="parse_from_output" + ), + pytest.param( + None, + "go1.21.4", + "go version\tgo1.21.4 \t\t linux/amd64", + id="parse_from_output_white_spaces", + ), + ], + ) + @mock.patch("cachi2.core.package_managers.gomod.Go._run") + def test_release( + self, + mock_run: mock.Mock, + release: Optional[str], + expect: str, + go_output: str, + ) -> None: + mock_run.return_value = go_output + + go = Go(release=release) + assert go.release == expect + + @mock.patch("cachi2.core.package_managers.gomod.Go._run") + def test_release_failure(self, mock_run: mock.Mock) -> None: + go_output = "go mangled version 1.21_4" + mock_run.return_value = go_output + + error_msg = f"Could not extract Go toolchain version from Go's output: '{go_output}'" + with pytest.raises(PackageManagerError, match=error_msg): + Go(release=None).release From bfa8314021b1881c28e55f6b29e817a75cfa9fca Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Tue, 16 Jan 2024 15:27:54 +0100 Subject: [PATCH 13/23] package_managers: gomod: Go: Implement version property This property is going to be used for comparisons with the recommended/required toolchain versions coming from go.mod file, so it returns packaging.version.Version instead of plain string. Signed-off-by: Erik Skultety --- cachi2/core/package_managers/gomod.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/cachi2/core/package_managers/gomod.py b/cachi2/core/package_managers/gomod.py index 9225ac5df..602d6174d 100644 --- a/cachi2/core/package_managers/gomod.py +++ b/cachi2/core/package_managers/gomod.py @@ -268,9 +268,11 @@ def __call__(self, cmd: list[str], params: Optional[dict] = None, retry: bool = return self._run(cmd, **params) @property - def version(self) -> version.Version: # type: ignore + def version(self) -> version.Version: """Version of the Go toolchain as a packaging.version.Version object.""" - pass + if not self._version: + self._version = version.Version(self.release[2:]) + return self._version @property def release(self) -> str: From 57f6282937a5db39841f49689fc64b3ca4f553b4 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Mon, 15 Jan 2024 17:38:34 +0100 Subject: [PATCH 14/23] package_managers: gomod: Introduce _get_gomod_version function helper This helper is crucial in that it determines our behaviour based on the Go version specified in the package's go.mod file. Unfortunately for us we cannot utilize Go's native functionality of parsing the go.mod file for us as older versions of Go will have issues with go.mod files based on newer version of the language. Therefore, let's extract the 'go ' line manually. Signed-off-by: Erik Skultety --- cachi2/core/package_managers/gomod.py | 19 +++++++++++++++ tests/unit/package_managers/test_gomod.py | 29 +++++++++++++++++++++++ 2 files changed, 48 insertions(+) diff --git a/cachi2/core/package_managers/gomod.py b/cachi2/core/package_managers/gomod.py index 602d6174d..9812ab253 100644 --- a/cachi2/core/package_managers/gomod.py +++ b/cachi2/core/package_managers/gomod.py @@ -664,6 +664,25 @@ def _get_repository_name(source_dir: RootedPath) -> str: return f"{url.hostname}{url.path.rstrip('/').removesuffix('.git')}" +def _get_gomod_version(source_dir: RootedPath) -> Optional[str]: + """Return the required/recommended version of Go from go.mod. + + We need to extract the desired version of Go ourselves as older versions of Go might fail + due to e.g. unknown keywords or unexpected format of the version (yes, Go always performs + validation of go.mod). + + If we cannot extract a version from the 'go' line, we return None, leaving it up to the caller + to decide what to do next. + """ + go_mod = source_dir.join_within_root("go.mod") + with open(go_mod) as f: + reg = re.compile(r"^\s*go\s+(?P\d\.\d+(:?.\d+)?)\s*$") + for line in f: + if match := re.match(reg, line): + return match.group("ver") + return None + + def _protect_against_symlinks(app_dir: RootedPath) -> None: """Try to prevent go subcommands from following suspicious symlinks. diff --git a/tests/unit/package_managers/test_gomod.py b/tests/unit/package_managers/test_gomod.py index 6cb319c0b..2eb6a19e2 100644 --- a/tests/unit/package_managers/test_gomod.py +++ b/tests/unit/package_managers/test_gomod.py @@ -30,6 +30,7 @@ _create_modules_from_parsed_data, _create_packages_from_parsed_data, _deduplicate_resolved_modules, + _get_gomod_version, _get_repository_name, _parse_go_sum, _parse_vendor, @@ -94,6 +95,14 @@ def gomod_request(tmp_path: Path, gomod_input_packages: list[dict[str, str]]) -> ) +@pytest.fixture +def go_mod_file(tmp_path: Path, request: pytest.FixtureRequest) -> None: + output_file = tmp_path / "go.mod" + + with open(output_file, "w") as f: + f.write(request.param) + + def proc_mock( args: Union[str, list[str]] = "", *, returncode: int, stdout: Optional[str] ) -> subprocess.CompletedProcess: @@ -1591,6 +1600,26 @@ def test_fetch_tags_fail(repo_remote_with_tag: tuple[RootedPath, RootedPath]) -> ModuleVersionResolver.from_repo_path(remote_repo_path) +@pytest.mark.parametrize( + "go_mod_file, go_mod_version", + [("go 1.21", "1.21"), (" go 1.21.4 ", "1.21.4")], + indirect=["go_mod_file"], +) +def test_get_gomod_version( + rooted_tmp_path: RootedPath, go_mod_file: Path, go_mod_version: str +) -> None: + assert _get_gomod_version(rooted_tmp_path) == go_mod_version + + +@pytest.mark.parametrize( + "go_mod_file", + [pytest.param(_, id=_) for _ in ["go1.21", "go 1.21.0.100", "1.21", "go 1.21 foo"]], + indirect=True, +) +def test_get_gomod_version_fail(rooted_tmp_path: RootedPath, go_mod_file: Path) -> None: + assert _get_gomod_version(rooted_tmp_path) is None + + class TestGo: @pytest.mark.parametrize( "bin_, params", From 80a5221cf95154483510285e24932f994cb0dfd8 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Fri, 12 Jan 2024 10:47:08 +0100 Subject: [PATCH 15/23] package_managers: gomod: Adopt the Go toolchain wrapping class This patch wires everything up by routing all 'go' calls through the wrapper class. Signed-off-by: Erik Skultety --- cachi2/core/package_managers/gomod.py | 56 ++++++++++++++++++----- tests/unit/package_managers/test_gomod.py | 49 ++++++++++++++++---- 2 files changed, 86 insertions(+), 19 deletions(-) diff --git a/cachi2/core/package_managers/gomod.py b/cachi2/core/package_managers/gomod.py index 9812ab253..6571f8971 100644 --- a/cachi2/core/package_managers/gomod.py +++ b/cachi2/core/package_managers/gomod.py @@ -769,30 +769,62 @@ def _resolve_gomod( run_params = {"env": env, "cwd": app_dir} + go = Go() + go1_21 = version.Version("1.21") + go_base_version = go.version + go_mod_version_msg = "go.mod recommends/requires Go version: {}" + + if (_ := _get_gomod_version(app_dir)) is None: + # Go added the 'go' directive to go.mod in 1.12 [1]. If missing, 1.16 is assumed [2]. + # For our version comparison purposes we set the version explicitly to 1.20 if missing. + # [1] https://go.dev/doc/go1.12#modules + # [2] https://go.dev/ref/mod#go-mod-file-go + _ = "1.20" + go_mod_version_msg += " " + "(cachi2 enforced)" + + go_mod_version = version.Version(_) + + log.info(go_mod_version_msg.format(go_mod_version)) + + if go_mod_version >= go1_21 and go_base_version < go1_21: + # our base Go installation is too old and we need a newer one to support new keywords + go = Go(release="go1.21.0") + elif go_mod_version < go1_21 and go_base_version >= go1_21: + # Starting with Go 1.21, Go doesn't try to be semantically backwards compatible in that the + # 'go X.Y' line now denotes the minimum required version of Go, no a "suggested" version. + # What it means in practice is that a Go toolchain >= 1.21 enforces the biggest + # common toolchain denominator across all dependencies and so if the input project + # specifies e.g. 'go 1.19' and **any** of its dependencies specify 'go 1.21' (or higher), + # then the default 1.21 toolchain will bump the input project's go.mod file to make sure + # the minimum required Go version is met across all dependencies. That is a problem, + # because it'll lead to fatal build failures forcing everyone to update their build + # recipes. Note that at some point they'll have to do that anyway, but until majority of + # projects in the ecosystem adopt 1.21, we need a fallback to an older toolchain version. + go = Go(release="go1.20") + # Vendor dependencies if the gomod-vendor flag is set flags = request.flags should_vendor, can_make_changes = _should_vendor_deps( flags, app_dir, config.gomod_strict_vendor ) if should_vendor: - downloaded_modules = _vendor_deps(app_dir, can_make_changes, run_params) + downloaded_modules = _vendor_deps(go, app_dir, can_make_changes, run_params) else: log.info("Downloading the gomod dependencies") - download_cmd = ["go", "mod", "download", "-json"] downloaded_modules = ( ParsedModule.model_validate(obj) - for obj in load_json_stream(_run_download_cmd(download_cmd, run_params)) + for obj in load_json_stream(go(["mod", "download", "-json"], run_params, retry=True)) ) if "force-gomod-tidy" in flags: - _run_gomod_cmd(("go", "mod", "tidy"), run_params) + go(["mod", "tidy"], run_params) - go_list = ["go", "list", "-e"] + go_list = ["list", "-e"] if not should_vendor: # Make Go ignore the vendor dir even if there is one go_list.extend(["-mod", "readonly"]) - main_module_name = _run_gomod_cmd([*go_list, "-m"], run_params).rstrip() + main_module_name = go([*go_list, "-m"], run_params).rstrip() main_module = ParsedModule( path=main_module_name, version=version_resolver.get_golang_version(main_module_name, app_dir), @@ -808,7 +840,7 @@ def go_list_deps(pattern: Literal["./...", "all"]) -> Iterator[ParsedPackage]: complete module list (roughly matching the list of downloaded modules). """ cmd = [*go_list, "-deps", "-json=ImportPath,Module,Standard,Deps", pattern] - return map(ParsedPackage.model_validate, load_json_stream(_run_gomod_cmd(cmd, run_params))) + return map(ParsedPackage.model_validate, load_json_stream(go(cmd, run_params))) package_modules = ( module for pkg in go_list_deps("all") if (module := pkg.module) and not module.main @@ -894,8 +926,7 @@ def __exit__( ) -> None: """Clean up the temporary directory by first cleaning up the Go cache.""" try: - env = {"GOPATH": self.name, "GOCACHE": self.name} - _run_gomod_cmd(("go", "clean", "-modcache"), {"env": env}) + Go()(["clean", "-modcache"], {"env": {"GOPATH": self.name, "GOCACHE": self.name}}) finally: super().__exit__(exc, value, tb) @@ -1339,7 +1370,10 @@ def parse_module_line(line: str) -> ParsedModule: def _vendor_deps( - app_dir: RootedPath, can_make_changes: bool, run_params: dict[str, Any] + go: Go, + app_dir: RootedPath, + can_make_changes: bool, + run_params: dict[str, Any], ) -> Iterable[ParsedModule]: """ Vendor golang dependencies. @@ -1355,7 +1389,7 @@ def _vendor_deps( :raise UnexpectedFormat: if Cachi2 fails to parse vendor/modules.txt """ log.info("Vendoring the gomod dependencies") - _run_download_cmd(("go", "mod", "vendor"), run_params) + go(["mod", "vendor"], run_params) if not can_make_changes and _vendor_changed(app_dir): raise PackageRejected( reason=( diff --git a/tests/unit/package_managers/test_gomod.py b/tests/unit/package_managers/test_gomod.py index 2eb6a19e2..38a0172a0 100644 --- a/tests/unit/package_managers/test_gomod.py +++ b/tests/unit/package_managers/test_gomod.py @@ -128,6 +128,8 @@ def _parse_mocked_data(data_dir: Path, file_path: str) -> ResolvedGoModule: @pytest.mark.parametrize("cgo_disable", [False, True]) @pytest.mark.parametrize("force_gomod_tidy", [False, True]) +@mock.patch("cachi2.core.package_managers.gomod.Go.release", new_callable=mock.PropertyMock) +@mock.patch("cachi2.core.package_managers.gomod._get_gomod_version") @mock.patch("cachi2.core.package_managers.gomod.ModuleVersionResolver") @mock.patch("cachi2.core.package_managers.gomod._validate_local_replacements") @mock.patch("subprocess.run") @@ -135,6 +137,8 @@ def test_resolve_gomod( mock_run: mock.Mock, mock_validate_local_replacements: mock.Mock, mock_version_resolver: mock.Mock, + mock_get_gomod_version: mock.Mock, + mock_go_release: mock.PropertyMock, cgo_disable: bool, force_gomod_tidy: bool, tmp_path: Path, @@ -176,6 +180,8 @@ def test_resolve_gomod( mock_run.side_effect = run_side_effects mock_version_resolver.get_golang_version.return_value = "v0.1.0" + mock_go_release.return_value = "go0.1.0" + mock_get_gomod_version.return_value = "0.1.1" flags: list[Flag] = [] if cgo_disable: @@ -229,6 +235,8 @@ def test_resolve_gomod( @pytest.mark.parametrize("force_gomod_tidy", [False, True]) +@mock.patch("cachi2.core.package_managers.gomod.Go.release", new_callable=mock.PropertyMock) +@mock.patch("cachi2.core.package_managers.gomod._get_gomod_version") @mock.patch("cachi2.core.package_managers.gomod.ModuleVersionResolver") @mock.patch("cachi2.core.package_managers.gomod._validate_local_replacements") @mock.patch("subprocess.run") @@ -236,6 +244,8 @@ def test_resolve_gomod_vendor_dependencies( mock_run: mock.Mock, mock_validate_local_replacements: mock.Mock, mock_version_resolver: mock.Mock, + mock_get_gomod_version: mock.Mock, + mock_go_release: mock.PropertyMock, force_gomod_tidy: bool, tmp_path: Path, data_dir: Path, @@ -270,6 +280,8 @@ def test_resolve_gomod_vendor_dependencies( mock_run.side_effect = run_side_effects mock_version_resolver.get_golang_version.return_value = "v0.1.0" + mock_go_release.return_value = "go0.1.0" + mock_get_gomod_version.return_value = "0.1.1" flags: list[Flag] = ["gomod-vendor"] if force_gomod_tidy: @@ -307,10 +319,19 @@ def test_resolve_gomod_vendor_dependencies( assert resolve_result.modules_in_go_sum == expect_result.modules_in_go_sum -def test_resolve_gomod_vendor_without_flag(tmp_path: Path, gomod_request: Request) -> None: +@mock.patch("cachi2.core.package_managers.gomod.Go.release", new_callable=mock.PropertyMock) +@mock.patch("cachi2.core.package_managers.gomod._get_gomod_version") +def test_resolve_gomod_vendor_without_flag( + mock_get_gomod_version: mock.Mock, + mock_go_release: mock.PropertyMock, + tmp_path: Path, + gomod_request: Request, +) -> None: module_dir = gomod_request.source_dir.join_within_root("path/to/module") module_dir.path.joinpath("vendor").mkdir(parents=True) version_resolver = mock.Mock() + mock_go_release.return_value = "go0.1.0" + mock_get_gomod_version.return_value = "0.1.1" expected_error = ( 'The "gomod-vendor" or "gomod-vendor-check" flag must be set when your repository has ' @@ -321,11 +342,15 @@ def test_resolve_gomod_vendor_without_flag(tmp_path: Path, gomod_request: Reques @pytest.mark.parametrize("force_gomod_tidy", [False, True]) +@mock.patch("cachi2.core.package_managers.gomod.Go.release", new_callable=mock.PropertyMock) +@mock.patch("cachi2.core.package_managers.gomod._get_gomod_version") @mock.patch("cachi2.core.package_managers.gomod.ModuleVersionResolver") @mock.patch("subprocess.run") def test_resolve_gomod_no_deps( mock_run: mock.Mock, mock_version_resolver: mock.Mock, + mock_get_gomod_version: mock.Mock, + mock_go_release: mock.PropertyMock, force_gomod_tidy: bool, tmp_path: Path, gomod_request: Request, @@ -367,6 +392,8 @@ def test_resolve_gomod_no_deps( mock_run.side_effect = run_side_effects mock_version_resolver.get_golang_version.return_value = "v2.1.1" + mock_go_release.return_value = "go2.1.0" + mock_get_gomod_version.return_value = "2.1.1" if force_gomod_tidy: gomod_request.flags = frozenset({"force-gomod-tidy"}) @@ -754,11 +781,15 @@ def test_package_to_component(package: Package, expected_component: Component) - @pytest.mark.parametrize(("go_mod_rc", "go_list_rc"), ((0, 1), (1, 0))) +@mock.patch("cachi2.core.package_managers.gomod.Go.release", new_callable=mock.PropertyMock) +@mock.patch("cachi2.core.package_managers.gomod._get_gomod_version") @mock.patch("cachi2.core.package_managers.gomod.get_config") @mock.patch("subprocess.run") def test_go_list_cmd_failure( mock_run: mock.Mock, mock_config: mock.Mock, + mock_get_gomod_version: mock.Mock, + mock_go_release: mock.PropertyMock, tmp_path: Path, go_mod_rc: int, go_list_rc: int, @@ -768,6 +799,8 @@ def test_go_list_cmd_failure( version_resolver = mock.Mock() mock_config.return_value.gomod_download_max_tries = 1 + mock_go_release.return_value = "go0.1.0" + mock_get_gomod_version.return_value = "0.1.1" # Mock the "subprocess.run" calls mock_run.side_effect = [ @@ -779,11 +812,11 @@ def test_go_list_cmd_failure( ), ] - expect_error = "Processing gomod dependencies failed" + expect_error = "Go execution failed: " if go_mod_rc == 0: - expect_error += ": `go list -e -mod readonly -m` failed with rc=1" + expect_error += "`go list -e -mod readonly -m` failed with rc=1" else: - expect_error += ". Cachi2 tried the go mod download -json command 1 times" + expect_error += "Cachi2 re-tried running `go mod download -json` command 1 times." with pytest.raises(PackageManagerError, match=expect_error): _resolve_gomod(module_path, gomod_request, tmp_path, version_resolver) @@ -1062,7 +1095,7 @@ def test_should_vendor_deps_strict( @pytest.mark.parametrize("can_make_changes", [True, False]) @pytest.mark.parametrize("vendor_changed", [True, False]) -@mock.patch("cachi2.core.package_managers.gomod._run_download_cmd") +@mock.patch("cachi2.core.package_managers.gomod.Go._run") @mock.patch("cachi2.core.package_managers.gomod._vendor_changed") def test_vendor_deps( mock_vendor_changed: mock.Mock, @@ -1079,11 +1112,11 @@ def test_vendor_deps( if expect_error: msg = "The content of the vendor directory is not consistent with go.mod." with pytest.raises(PackageRejected, match=msg): - _vendor_deps(app_dir, can_make_changes, run_params) + _vendor_deps(Go(), app_dir, can_make_changes, run_params) else: - _vendor_deps(app_dir, can_make_changes, run_params) + _vendor_deps(Go(), app_dir, can_make_changes, run_params) - mock_run_cmd.assert_called_once_with(("go", "mod", "vendor"), run_params) + mock_run_cmd.assert_called_once_with(["go", "mod", "vendor"], **run_params) if not can_make_changes: mock_vendor_changed.assert_called_once_with(app_dir) From 334a2cb8b4a746bfb73699d9a03ff0763b9f12a8 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Fri, 12 Jan 2024 10:46:23 +0100 Subject: [PATCH 16/23] package_managers: gomod: Don't log Go's version outside a Go instance We used to log the version of Go used for pre-fetching of the deps. We can still do that, but not outside of a Go instance since we may need alternate version of SDK to be installed, so that information would then be misleading. Since we already log this (and much more) as part of the Go class, we don't need the dropped hunk anymore. Signed-off-by: Erik Skultety --- cachi2/core/package_managers/gomod.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/cachi2/core/package_managers/gomod.py b/cachi2/core/package_managers/gomod.py index 6571f8971..8bfe26b25 100644 --- a/cachi2/core/package_managers/gomod.py +++ b/cachi2/core/package_managers/gomod.py @@ -542,9 +542,6 @@ def fetch_gomod_source(request: Request) -> RequestOutput: :raises PackageRejected: if a file is not present for the gomod package manager :raises PackageManagerError: if failed to fetch gomod dependencies """ - version_output = run_cmd(["go", "version"], {}) - log.info(f"Go version: {version_output.strip()}") - config = get_config() subpaths = [str(package.path) for package in request.gomod_packages] From 86108867cb0d6bfc2c7fe198d2c8c83c277ff188 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Mon, 15 Jan 2024 17:39:03 +0100 Subject: [PATCH 17/23] package_managers: gomod: Drop _run_download_cmd and _run_gomod_cmd The logic of these helpers has been extracted into the Go class and so these have become unused and can be dropped. Signed-off-by: Erik Skultety --- cachi2/core/package_managers/gomod.py | 45 ------------------- tests/unit/package_managers/test_gomod.py | 55 ----------------------- 2 files changed, 100 deletions(-) diff --git a/cachi2/core/package_managers/gomod.py b/cachi2/core/package_managers/gomod.py index 8bfe26b25..f9dd2b8de 100644 --- a/cachi2/core/package_managers/gomod.py +++ b/cachi2/core/package_managers/gomod.py @@ -12,14 +12,12 @@ from typing import ( TYPE_CHECKING, Any, - Dict, Iterable, Iterator, Literal, NamedTuple, NoReturn, Optional, - Sequence, Tuple, Type, Union, @@ -524,16 +522,6 @@ def _resolve_package_relative_path(package: ParsedPackage, module: Module) -> st return [_create_package(package) for package in parsed_packages] -def _run_gomod_cmd(cmd: Sequence[str], params: dict[str, Any]) -> str: - try: - return run_cmd(cmd, params) - except subprocess.CalledProcessError as e: - rc = e.returncode - raise PackageManagerError( - f"Processing gomod dependencies failed: `{' '.join(cmd)}` failed with {rc=}" - ) from e - - def fetch_gomod_source(request: Request) -> RequestOutput: """ Resolve and fetch gomod dependencies for a given request. @@ -928,39 +916,6 @@ def __exit__( super().__exit__(exc, value, tb) -def _run_download_cmd(cmd: Sequence[str], params: Dict[str, Any]) -> str: - """Run gomod command that downloads dependencies. - - Such commands may fail due to network errors (go is bad at retrying), so the entire operation - will be retried a configurable number of times. - - Cachi2 will reuse the same cache directory between retries, so Go will not have to download - the same dependency twice. The backoff is exponential, Cachi2 will wait 1s -> 2s -> 4s -> ... - before retrying. - """ - n_tries = get_config().gomod_download_max_tries - - @backoff.on_exception( - backoff.expo, - PackageManagerError, - jitter=None, # use deterministic backoff, do not apply jitter - max_tries=n_tries, - logger=log, - ) - def run_go(_cmd: Sequence[str], _params: Dict[str, Any]) -> str: - log.debug(f"Running {_cmd}") - return _run_gomod_cmd(_cmd, _params) - - try: - return run_go(cmd, params) - except PackageManagerError: - err_msg = ( - f"Processing gomod dependencies failed. Cachi2 tried the {' '.join(cmd)} command " - f"{n_tries} times." - ) - raise PackageManagerError(err_msg) from None - - def _should_vendor_deps( flags: Iterable[str], app_dir: RootedPath, strict: bool ) -> Tuple[bool, bool]: diff --git a/tests/unit/package_managers/test_gomod.py b/tests/unit/package_managers/test_gomod.py index 38a0172a0..fda28026b 100644 --- a/tests/unit/package_managers/test_gomod.py +++ b/tests/unit/package_managers/test_gomod.py @@ -35,7 +35,6 @@ _parse_go_sum, _parse_vendor, _resolve_gomod, - _run_download_cmd, _should_vendor_deps, _validate_local_replacements, _vendor_changed, @@ -1288,60 +1287,6 @@ def test_vendor_changed( assert not repo.git.diff("--diff-filter", "A") -@pytest.mark.parametrize("tries_needed", [1, 2, 3, 4, 5]) -@mock.patch("cachi2.core.package_managers.gomod.get_config") -@mock.patch("subprocess.run") -@mock.patch("time.sleep") -def test_run_download_cmd_success( - mock_sleep: Any, - mock_run: Any, - mock_config: Any, - tries_needed: int, - caplog: pytest.LogCaptureFixture, -) -> None: - mock_config.return_value.gomod_download_max_tries = 5 - - failure = proc_mock(returncode=1, stdout="") - success = proc_mock(returncode=0, stdout="") - mock_run.side_effect = [failure for _ in range(tries_needed - 1)] + [success] - - _run_download_cmd(["go", "mod", "download"], {}) - assert mock_run.call_count == tries_needed - assert mock_sleep.call_count == tries_needed - 1 - - for n in range(tries_needed - 1): - wait = 2**n - assert f"Backing off run_go(...) for {wait:.1f}s" in caplog.text - - -@mock.patch("cachi2.core.package_managers.gomod.get_config") -@mock.patch("subprocess.run") -@mock.patch("time.sleep") -def test_run_download_cmd_failure( - mock_sleep: Any, mock_run: Any, mock_config: Any, caplog: pytest.LogCaptureFixture -) -> None: - mock_config.return_value.gomod_download_max_tries = 5 - - failure = proc_mock(returncode=1, stdout="") - mock_run.side_effect = [failure] * 5 - - expect_msg = ( - "Processing gomod dependencies failed. Cachi2 tried the go mod download command 5 times." - ) - - with pytest.raises(PackageManagerError, match=expect_msg): - _run_download_cmd(["go", "mod", "download"], {}) - - assert mock_run.call_count == 5 - assert mock_sleep.call_count == 4 - - assert "Backing off run_go(...) for 1.0s" in caplog.text - assert "Backing off run_go(...) for 2.0s" in caplog.text - assert "Backing off run_go(...) for 4.0s" in caplog.text - assert "Backing off run_go(...) for 8.0s" in caplog.text - assert "Giving up run_go(...) after 5 tries" in caplog.text - - @pytest.mark.parametrize( "file_tree", ( From 7f73464a698245d36e12bf4aacc3c80d7fd20342 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Mon, 11 Dec 2023 14:26:58 +0100 Subject: [PATCH 18/23] package_managers: gomod: Add preliminary support for Go 1.21 One of Go 1.21's main features is specifying the suggested version of toolchain to be used for compiling modules as a means of forwards compatibility. However, this patch only adds preliminary support for Go 1.21 in that it essentially explicitly denies usage of toolchains (which is fine, because those versions are only suggestive, Go always prefers building with the bundled toolchain anyway) by the means of explicitly setting the GOTOOLCHAIN env variable to 'local' which instructs Go to always use the bundled toolchain (provided it's new enough to conform to the minimum required version of Go indicated by the 'go' line). This patch makes sure we set GOTOOLCHAIN=local during both pre-fetch as well as for user container builds. Future patches will add proper support for 1.21 dealing with alternative toolchain versions that will need to be prefetched. STONEBLD-2046 Signed-off-by: Erik Skultety --- cachi2/core/package_managers/gomod.py | 2 ++ .../test_data/gomod_e2e_multiple_modules/.build-config.yaml | 3 +++ tests/integration/test_data/gomod_e2e_test/.build-config.yaml | 3 +++ .../test_data/gomod_go_generate_imported/.build-config.yaml | 3 +++ .../integration/test_data/gomod_local_deps/.build-config.yaml | 3 +++ .../.build-config.yaml | 3 +++ .../gomod_vendor_check_correct_vendor/.build-config.yaml | 3 +++ .../test_data/gomod_vendor_check_no_vendor/.build-config.yaml | 3 +++ .../test_data/gomod_vendored_with_flag/.build-config.yaml | 3 +++ tests/integration/test_data/gomod_with_deps/.build-config.yaml | 3 +++ .../test_data/gomod_without_deps/.build-config.yaml | 3 +++ tests/unit/package_managers/test_gomod.py | 1 + 12 files changed, 33 insertions(+) diff --git a/cachi2/core/package_managers/gomod.py b/cachi2/core/package_managers/gomod.py index f9dd2b8de..7f98b677b 100644 --- a/cachi2/core/package_managers/gomod.py +++ b/cachi2/core/package_managers/gomod.py @@ -551,6 +551,7 @@ def fetch_gomod_source(request: Request) -> RequestOutput: "GOCACHE": {"value": "deps/gomod", "kind": "path"}, "GOPATH": {"value": "deps/gomod", "kind": "path"}, "GOMODCACHE": {"value": "deps/gomod/pkg/mod", "kind": "path"}, + "GOTOOLCHAIN": {"value": "local", "kind": "literal"}, } env_vars.update(config.default_environment_variables.get("gomod", {})) @@ -744,6 +745,7 @@ def _resolve_gomod( "PATH": os.environ.get("PATH", ""), "GOMODCACHE": "{}/pkg/mod".format(tmp_dir), "GOSUMDB": "sum.golang.org", + "GOTOOLCHAIN": "local", } if config.goproxy_url: diff --git a/tests/integration/test_data/gomod_e2e_multiple_modules/.build-config.yaml b/tests/integration/test_data/gomod_e2e_multiple_modules/.build-config.yaml index 6bb6f5465..be5ed9355 100644 --- a/tests/integration/test_data/gomod_e2e_multiple_modules/.build-config.yaml +++ b/tests/integration/test_data/gomod_e2e_multiple_modules/.build-config.yaml @@ -8,4 +8,7 @@ environment_variables: - kind: path name: GOPATH value: deps/gomod +- kind: literal + name: GOTOOLCHAIN + value: local project_files: [] diff --git a/tests/integration/test_data/gomod_e2e_test/.build-config.yaml b/tests/integration/test_data/gomod_e2e_test/.build-config.yaml index 6bb6f5465..be5ed9355 100644 --- a/tests/integration/test_data/gomod_e2e_test/.build-config.yaml +++ b/tests/integration/test_data/gomod_e2e_test/.build-config.yaml @@ -8,4 +8,7 @@ environment_variables: - kind: path name: GOPATH value: deps/gomod +- kind: literal + name: GOTOOLCHAIN + value: local project_files: [] diff --git a/tests/integration/test_data/gomod_go_generate_imported/.build-config.yaml b/tests/integration/test_data/gomod_go_generate_imported/.build-config.yaml index 6bb6f5465..be5ed9355 100644 --- a/tests/integration/test_data/gomod_go_generate_imported/.build-config.yaml +++ b/tests/integration/test_data/gomod_go_generate_imported/.build-config.yaml @@ -8,4 +8,7 @@ environment_variables: - kind: path name: GOPATH value: deps/gomod +- kind: literal + name: GOTOOLCHAIN + value: local project_files: [] diff --git a/tests/integration/test_data/gomod_local_deps/.build-config.yaml b/tests/integration/test_data/gomod_local_deps/.build-config.yaml index 6bb6f5465..be5ed9355 100644 --- a/tests/integration/test_data/gomod_local_deps/.build-config.yaml +++ b/tests/integration/test_data/gomod_local_deps/.build-config.yaml @@ -8,4 +8,7 @@ environment_variables: - kind: path name: GOPATH value: deps/gomod +- kind: literal + name: GOTOOLCHAIN + value: local project_files: [] diff --git a/tests/integration/test_data/gomod_multiple_modules_missing_checksums/.build-config.yaml b/tests/integration/test_data/gomod_multiple_modules_missing_checksums/.build-config.yaml index 6bb6f5465..be5ed9355 100644 --- a/tests/integration/test_data/gomod_multiple_modules_missing_checksums/.build-config.yaml +++ b/tests/integration/test_data/gomod_multiple_modules_missing_checksums/.build-config.yaml @@ -8,4 +8,7 @@ environment_variables: - kind: path name: GOPATH value: deps/gomod +- kind: literal + name: GOTOOLCHAIN + value: local project_files: [] diff --git a/tests/integration/test_data/gomod_vendor_check_correct_vendor/.build-config.yaml b/tests/integration/test_data/gomod_vendor_check_correct_vendor/.build-config.yaml index 6bb6f5465..be5ed9355 100644 --- a/tests/integration/test_data/gomod_vendor_check_correct_vendor/.build-config.yaml +++ b/tests/integration/test_data/gomod_vendor_check_correct_vendor/.build-config.yaml @@ -8,4 +8,7 @@ environment_variables: - kind: path name: GOPATH value: deps/gomod +- kind: literal + name: GOTOOLCHAIN + value: local project_files: [] diff --git a/tests/integration/test_data/gomod_vendor_check_no_vendor/.build-config.yaml b/tests/integration/test_data/gomod_vendor_check_no_vendor/.build-config.yaml index 6bb6f5465..be5ed9355 100644 --- a/tests/integration/test_data/gomod_vendor_check_no_vendor/.build-config.yaml +++ b/tests/integration/test_data/gomod_vendor_check_no_vendor/.build-config.yaml @@ -8,4 +8,7 @@ environment_variables: - kind: path name: GOPATH value: deps/gomod +- kind: literal + name: GOTOOLCHAIN + value: local project_files: [] diff --git a/tests/integration/test_data/gomod_vendored_with_flag/.build-config.yaml b/tests/integration/test_data/gomod_vendored_with_flag/.build-config.yaml index 6bb6f5465..be5ed9355 100644 --- a/tests/integration/test_data/gomod_vendored_with_flag/.build-config.yaml +++ b/tests/integration/test_data/gomod_vendored_with_flag/.build-config.yaml @@ -8,4 +8,7 @@ environment_variables: - kind: path name: GOPATH value: deps/gomod +- kind: literal + name: GOTOOLCHAIN + value: local project_files: [] diff --git a/tests/integration/test_data/gomod_with_deps/.build-config.yaml b/tests/integration/test_data/gomod_with_deps/.build-config.yaml index 6bb6f5465..be5ed9355 100644 --- a/tests/integration/test_data/gomod_with_deps/.build-config.yaml +++ b/tests/integration/test_data/gomod_with_deps/.build-config.yaml @@ -8,4 +8,7 @@ environment_variables: - kind: path name: GOPATH value: deps/gomod +- kind: literal + name: GOTOOLCHAIN + value: local project_files: [] diff --git a/tests/integration/test_data/gomod_without_deps/.build-config.yaml b/tests/integration/test_data/gomod_without_deps/.build-config.yaml index 6bb6f5465..be5ed9355 100644 --- a/tests/integration/test_data/gomod_without_deps/.build-config.yaml +++ b/tests/integration/test_data/gomod_without_deps/.build-config.yaml @@ -8,4 +8,7 @@ environment_variables: - kind: path name: GOPATH value: deps/gomod +- kind: literal + name: GOTOOLCHAIN + value: local project_files: [] diff --git a/tests/unit/package_managers/test_gomod.py b/tests/unit/package_managers/test_gomod.py index fda28026b..5d77d15ff 100644 --- a/tests/unit/package_managers/test_gomod.py +++ b/tests/unit/package_managers/test_gomod.py @@ -59,6 +59,7 @@ def env_variables() -> list[dict[str, str]]: {"name": "GOCACHE", "value": "deps/gomod", "kind": "path"}, {"name": "GOMODCACHE", "value": "deps/gomod/pkg/mod", "kind": "path"}, {"name": "GOPATH", "value": "deps/gomod", "kind": "path"}, + {"name": "GOTOOLCHAIN", "value": "local", "kind": "literal"}, ] From dc6023ebce6321e53a70b99f85f99b0c91194639 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Mon, 11 Dec 2023 14:21:38 +0100 Subject: [PATCH 19/23] Containerfile: Bump the image from Fedora 38 -> 39 The main motivation behind this change is the Go 1.21 version which isn't available on Fedora 38 but is on Fedora 39. Resolves: https://github.com/containerbuildsystem/cachi2/issues/387 Signed-off-by: Erik Skultety --- Containerfile | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/Containerfile b/Containerfile index 8ecf427a9..fc43c6ae5 100644 --- a/Containerfile +++ b/Containerfile @@ -1,4 +1,4 @@ -FROM registry.fedoraproject.org/fedora-minimal:38 +FROM registry.fedoraproject.org/fedora-minimal:39 LABEL maintainer="Red Hat" WORKDIR /src @@ -28,4 +28,16 @@ RUN npm install && \ corepack enable yarn && \ microdnf -y remove nodejs-npm +# Install an older version of Go fixed at 1.20 (along with the base >=1.21): +# - install Go's official shim +# - let the shim download the actual Go SDK (the download forces the output parent dir to $HOME) +# - move the SDK to a host local install system-wide location +# - remove the shim as it forces and expects the SDK to be used from $HOME +# - clean any build artifacts Go creates as part of the process. +RUN go install 'golang.org/dl/go1.20@latest' && \ + "$HOME/go/bin/go1.20" download && \ + mkdir /usr/local/go && \ + mv "$HOME/sdk/go1.20" /usr/local/go && \ + rm -rf "$HOME/go" "$HOME/.cache/go-build/" + ENTRYPOINT ["cachi2"] From 3a916a0915836b5bf40f0a0b71246be4095b5de1 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Tue, 16 Jan 2024 14:50:35 +0100 Subject: [PATCH 20/23] tests: unit: gomod: Update mock data with Go 1.21 Since we bumped the container image to Fedora 39 shipping with 1.21, we need to update our Go mock data with 1.21. Signed-off-by: Erik Skultety --- .../expected-results/resolve_gomod.json | 63 +- .../resolve_gomod_vendored.json | 63 +- .../non-vendored/go_list_deps_all.json | 1091 ++++++++++++----- .../non-vendored/go_list_deps_threedot.json | 785 ++++++++---- .../vendored/go_list_deps_all.json | 1091 ++++++++++++----- .../vendored/go_list_deps_threedot.json | 785 ++++++++---- 6 files changed, 2846 insertions(+), 1032 deletions(-) diff --git a/tests/unit/data/gomod-mocks/expected-results/resolve_gomod.json b/tests/unit/data/gomod-mocks/expected-results/resolve_gomod.json index d97b9dcf2..c71515787 100644 --- a/tests/unit/data/gomod-mocks/expected-results/resolve_gomod.json +++ b/tests/unit/data/gomod-mocks/expected-results/resolve_gomod.json @@ -155,12 +155,12 @@ "module": null }, { - "import_path": "internal/unsafeheader", + "import_path": "internal/abi", "standard": true, "module": null }, { - "import_path": "internal/abi", + "import_path": "internal/unsafeheader", "standard": true, "module": null }, @@ -174,6 +174,16 @@ "standard": true, "module": null }, + { + "import_path": "internal/coverage/rtcov", + "standard": true, + "module": null + }, + { + "import_path": "internal/godebugs", + "standard": true, + "module": null + }, { "import_path": "internal/goexperiment", "standard": true, @@ -420,7 +430,7 @@ "module": null }, { - "import_path": "crypto/internal/subtle", + "import_path": "crypto/internal/alias", "standard": true, "module": null }, @@ -499,6 +509,11 @@ "replace": null } }, + { + "import_path": "log/internal", + "standard": true, + "module": null + }, { "import_path": "log", "standard": true, @@ -514,6 +529,11 @@ "standard": true, "module": null }, + { + "import_path": "internal/bisect", + "standard": true, + "module": null + }, { "import_path": "internal/godebug", "standard": true, @@ -669,6 +689,11 @@ "standard": true, "module": null }, + { + "import_path": "internal/platform", + "standard": true, + "module": null + }, { "import_path": "go/build", "standard": true, @@ -739,6 +764,11 @@ "standard": true, "module": null }, + { + "import_path": "crypto/internal/edwards25519/field", + "standard": true, + "module": null + }, { "import_path": "crypto/internal/nistec/fiat", "standard": true, @@ -754,11 +784,21 @@ "standard": true, "module": null }, + { + "import_path": "crypto/ecdh", + "standard": true, + "module": null + }, { "import_path": "crypto/elliptic", "standard": true, "module": null }, + { + "import_path": "crypto/internal/bigmod", + "standard": true, + "module": null + }, { "import_path": "crypto/internal/boring/bbig", "standard": true, @@ -789,11 +829,6 @@ "standard": true, "module": null }, - { - "import_path": "crypto/internal/edwards25519/field", - "standard": true, - "module": null - }, { "import_path": "crypto/internal/edwards25519", "standard": true, @@ -855,7 +890,7 @@ "module": null }, { - "import_path": "vendor/golang.org/x/crypto/internal/subtle", + "import_path": "vendor/golang.org/x/crypto/internal/alias", "standard": true, "module": null }, @@ -879,16 +914,6 @@ "standard": true, "module": null }, - { - "import_path": "vendor/golang.org/x/crypto/curve25519/internal/field", - "standard": true, - "module": null - }, - { - "import_path": "vendor/golang.org/x/crypto/curve25519", - "standard": true, - "module": null - }, { "import_path": "vendor/golang.org/x/crypto/hkdf", "standard": true, diff --git a/tests/unit/data/gomod-mocks/expected-results/resolve_gomod_vendored.json b/tests/unit/data/gomod-mocks/expected-results/resolve_gomod_vendored.json index a8fab7522..127b17768 100644 --- a/tests/unit/data/gomod-mocks/expected-results/resolve_gomod_vendored.json +++ b/tests/unit/data/gomod-mocks/expected-results/resolve_gomod_vendored.json @@ -166,12 +166,12 @@ "module": null }, { - "import_path": "internal/unsafeheader", + "import_path": "internal/abi", "standard": true, "module": null }, { - "import_path": "internal/abi", + "import_path": "internal/unsafeheader", "standard": true, "module": null }, @@ -185,6 +185,16 @@ "standard": true, "module": null }, + { + "import_path": "internal/coverage/rtcov", + "standard": true, + "module": null + }, + { + "import_path": "internal/godebugs", + "standard": true, + "module": null + }, { "import_path": "internal/goexperiment", "standard": true, @@ -431,7 +441,7 @@ "module": null }, { - "import_path": "crypto/internal/subtle", + "import_path": "crypto/internal/alias", "standard": true, "module": null }, @@ -510,6 +520,11 @@ "replace": null } }, + { + "import_path": "log/internal", + "standard": true, + "module": null + }, { "import_path": "log", "standard": true, @@ -525,6 +540,11 @@ "standard": true, "module": null }, + { + "import_path": "internal/bisect", + "standard": true, + "module": null + }, { "import_path": "internal/godebug", "standard": true, @@ -680,6 +700,11 @@ "standard": true, "module": null }, + { + "import_path": "internal/platform", + "standard": true, + "module": null + }, { "import_path": "go/build", "standard": true, @@ -750,6 +775,11 @@ "standard": true, "module": null }, + { + "import_path": "crypto/internal/edwards25519/field", + "standard": true, + "module": null + }, { "import_path": "crypto/internal/nistec/fiat", "standard": true, @@ -765,11 +795,21 @@ "standard": true, "module": null }, + { + "import_path": "crypto/ecdh", + "standard": true, + "module": null + }, { "import_path": "crypto/elliptic", "standard": true, "module": null }, + { + "import_path": "crypto/internal/bigmod", + "standard": true, + "module": null + }, { "import_path": "crypto/internal/boring/bbig", "standard": true, @@ -800,11 +840,6 @@ "standard": true, "module": null }, - { - "import_path": "crypto/internal/edwards25519/field", - "standard": true, - "module": null - }, { "import_path": "crypto/internal/edwards25519", "standard": true, @@ -866,7 +901,7 @@ "module": null }, { - "import_path": "vendor/golang.org/x/crypto/internal/subtle", + "import_path": "vendor/golang.org/x/crypto/internal/alias", "standard": true, "module": null }, @@ -890,16 +925,6 @@ "standard": true, "module": null }, - { - "import_path": "vendor/golang.org/x/crypto/curve25519/internal/field", - "standard": true, - "module": null - }, - { - "import_path": "vendor/golang.org/x/crypto/curve25519", - "standard": true, - "module": null - }, { "import_path": "vendor/golang.org/x/crypto/hkdf", "standard": true, diff --git a/tests/unit/data/gomod-mocks/non-vendored/go_list_deps_all.json b/tests/unit/data/gomod-mocks/non-vendored/go_list_deps_all.json index 3553f21be..4ec4aad74 100644 --- a/tests/unit/data/gomod-mocks/non-vendored/go_list_deps_all.json +++ b/tests/unit/data/gomod-mocks/non-vendored/go_list_deps_all.json @@ -7,17 +7,17 @@ "Standard": true } { - "ImportPath": "internal/unsafeheader", + "ImportPath": "internal/abi", "Standard": true, "Deps": [ + "internal/goarch", "unsafe" ] } { - "ImportPath": "internal/abi", + "ImportPath": "internal/unsafeheader", "Standard": true, "Deps": [ - "internal/goarch", "unsafe" ] } @@ -33,6 +33,14 @@ "unsafe" ] } +{ + "ImportPath": "internal/coverage/rtcov", + "Standard": true +} +{ + "ImportPath": "internal/godebugs", + "Standard": true +} { "ImportPath": "internal/goexperiment", "Standard": true @@ -76,8 +84,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "runtime/internal/atomic", @@ -93,8 +103,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/unsafeheader", @@ -112,8 +124,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -146,8 +160,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -167,8 +183,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -199,8 +217,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -226,8 +246,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -254,8 +276,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -302,8 +326,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -326,8 +352,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -355,8 +383,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -377,8 +407,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -409,8 +441,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -430,8 +464,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -456,8 +492,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -483,8 +521,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -510,8 +550,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -540,8 +582,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -561,8 +605,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -587,8 +633,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -609,8 +657,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -631,8 +681,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -664,8 +716,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -703,9 +757,11 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -751,9 +807,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -797,8 +855,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -829,8 +889,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -855,8 +917,10 @@ "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -887,9 +951,11 @@ "hash/crc32", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -937,8 +1003,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -966,8 +1034,10 @@ "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -989,7 +1059,7 @@ ] } { - "ImportPath": "crypto/internal/subtle", + "ImportPath": "crypto/internal/alias", "Standard": true, "Deps": [ "unsafe" @@ -1003,14 +1073,17 @@ "ImportPath": "crypto/cipher", "Standard": true, "Deps": [ - "crypto/internal/subtle", + "bytes", + "crypto/internal/alias", "crypto/subtle", "encoding/binary", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1042,18 +1115,21 @@ "ImportPath": "crypto/internal/boring", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1081,19 +1157,22 @@ "ImportPath": "crypto/aes", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1121,15 +1200,18 @@ "ImportPath": "crypto/des", "Standard": true, "Deps": [ + "bytes", "crypto/cipher", - "crypto/internal/subtle", + "crypto/internal/alias", "crypto/subtle", "encoding/binary", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1160,8 +1242,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -1178,14 +1262,65 @@ "unsafe" ] } +{ + "ImportPath": "internal/bisect", + "Standard": true, + "Deps": [ + "internal/abi", + "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/goarch", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/race", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "sync", + "sync/atomic", + "unsafe" + ] +} +{ + "ImportPath": "internal/godebug", + "Standard": true, + "Deps": [ + "internal/abi", + "internal/bisect", + "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/goarch", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/race", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "sync", + "sync/atomic", + "unsafe" + ] +} { "ImportPath": "math/rand", "Standard": true, "Deps": [ "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -1210,10 +1345,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1261,10 +1400,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1303,6 +1446,42 @@ "unsafe" ] } +{ + "ImportPath": "crypto/internal/edwards25519/field", + "Standard": true, + "Deps": [ + "crypto/subtle", + "encoding/binary", + "errors", + "internal/abi", + "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/goarch", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/itoa", + "internal/race", + "internal/reflectlite", + "internal/unsafeheader", + "io", + "math", + "math/bits", + "reflect", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "strconv", + "sync", + "sync/atomic", + "unicode", + "unicode/utf8", + "unsafe" + ] +} { "ImportPath": "crypto/internal/nistec/fiat", "Standard": true, @@ -1311,8 +1490,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -1333,8 +1514,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1371,8 +1554,64 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/itoa", + "internal/oserror", + "internal/race", + "internal/reflectlite", + "internal/unsafeheader", + "io", + "io/fs", + "math", + "math/bits", + "path", + "reflect", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "sort", + "strconv", + "sync", + "sync/atomic", + "syscall", + "time", + "unicode", + "unicode/utf8", + "unsafe" + ] +} +{ + "ImportPath": "crypto/ecdh", + "Standard": true, + "Deps": [ + "bytes", + "crypto", + "crypto/cipher", + "crypto/internal/alias", + "crypto/internal/boring", + "crypto/internal/boring/sig", + "crypto/internal/edwards25519/field", + "crypto/internal/nistec", + "crypto/internal/nistec/fiat", + "crypto/internal/randutil", + "crypto/subtle", + "embed", + "encoding/binary", + "errors", + "hash", + "internal/abi", + "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1415,10 +1654,69 @@ "errors", "fmt", "internal/abi", + "internal/bisect", + "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/fmtsort", + "internal/goarch", + "internal/godebug", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/itoa", + "internal/oserror", + "internal/poll", + "internal/race", + "internal/reflectlite", + "internal/safefilepath", + "internal/syscall/execenv", + "internal/syscall/unix", + "internal/testlog", + "internal/unsafeheader", + "io", + "io/fs", + "math", + "math/big", + "math/bits", + "math/rand", + "os", + "path", + "reflect", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "sort", + "strconv", + "strings", + "sync", + "sync/atomic", + "syscall", + "time", + "unicode", + "unicode/utf8", + "unsafe" + ] +} +{ + "ImportPath": "crypto/internal/bigmod", + "Standard": true, + "Deps": [ + "bytes", + "encoding/binary", + "errors", + "fmt", + "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1464,19 +1762,23 @@ "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1519,19 +1821,22 @@ "ImportPath": "crypto/sha512", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1568,10 +1873,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1625,10 +1934,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1677,14 +1990,17 @@ "crypto", "crypto/aes", "crypto/cipher", + "crypto/ecdh", "crypto/elliptic", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", + "crypto/internal/edwards25519/field", "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/sha512", "crypto/subtle", "embed", @@ -1694,10 +2010,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1739,40 +2059,6 @@ "vendor/golang.org/x/crypto/cryptobyte/asn1" ] } -{ - "ImportPath": "crypto/internal/edwards25519/field", - "Standard": true, - "Deps": [ - "crypto/subtle", - "encoding/binary", - "errors", - "internal/abi", - "internal/bytealg", - "internal/cpu", - "internal/goarch", - "internal/goexperiment", - "internal/goos", - "internal/itoa", - "internal/race", - "internal/reflectlite", - "internal/unsafeheader", - "io", - "math", - "math/bits", - "reflect", - "runtime", - "runtime/internal/atomic", - "runtime/internal/math", - "runtime/internal/sys", - "runtime/internal/syscall", - "strconv", - "sync", - "sync/atomic", - "unicode", - "unicode/utf8", - "unsafe" - ] -} { "ImportPath": "crypto/internal/edwards25519", "Standard": true, @@ -1783,8 +2069,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1815,20 +2103,24 @@ "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1874,12 +2166,12 @@ "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", "crypto/internal/edwards25519", "crypto/internal/edwards25519/field", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/rand", "crypto/sha512", "crypto/subtle", @@ -1888,10 +2180,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1934,19 +2230,22 @@ "ImportPath": "crypto/hmac", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1980,8 +2279,10 @@ "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2009,12 +2310,14 @@ "ImportPath": "crypto/rc4", "Standard": true, "Deps": [ - "crypto/internal/subtle", + "crypto/internal/alias", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -2038,11 +2341,12 @@ "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/rand", "crypto/subtle", "encoding/binary", @@ -2050,10 +2354,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2096,19 +2404,22 @@ "ImportPath": "crypto/sha1", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2136,19 +2447,22 @@ "ImportPath": "crypto/sha256", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2180,9 +2494,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2230,10 +2546,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2281,8 +2601,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2316,8 +2638,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2343,46 +2667,6 @@ "unsafe" ] } -{ - "ImportPath": "internal/godebug", - "Standard": true, - "Deps": [ - "errors", - "internal/abi", - "internal/bytealg", - "internal/cpu", - "internal/goarch", - "internal/goexperiment", - "internal/goos", - "internal/itoa", - "internal/oserror", - "internal/poll", - "internal/race", - "internal/reflectlite", - "internal/safefilepath", - "internal/syscall/execenv", - "internal/syscall/unix", - "internal/testlog", - "internal/unsafeheader", - "io", - "io/fs", - "math/bits", - "os", - "path", - "runtime", - "runtime/internal/atomic", - "runtime/internal/math", - "runtime/internal/sys", - "runtime/internal/syscall", - "sort", - "sync", - "sync/atomic", - "syscall", - "time", - "unicode/utf8", - "unsafe" - ] -} { "ImportPath": "vendor/golang.org/x/net/dns/dnsmessage", "Standard": true, @@ -2390,8 +2674,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -2414,8 +2700,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -2433,40 +2721,24 @@ "ImportPath": "internal/intern", "Standard": true, "Deps": [ - "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", - "internal/itoa", - "internal/oserror", - "internal/poll", "internal/race", - "internal/reflectlite", - "internal/safefilepath", - "internal/syscall/execenv", - "internal/syscall/unix", - "internal/testlog", - "internal/unsafeheader", - "io", - "io/fs", - "math/bits", - "os", - "path", "runtime", "runtime/internal/atomic", "runtime/internal/math", "runtime/internal/sys", "runtime/internal/syscall", - "sort", "sync", "sync/atomic", - "syscall", - "time", - "unicode/utf8", "unsafe" ] } @@ -2476,40 +2748,30 @@ "Deps": [ "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", "internal/itoa", - "internal/oserror", - "internal/poll", "internal/race", "internal/reflectlite", - "internal/safefilepath", - "internal/syscall/execenv", - "internal/syscall/unix", - "internal/testlog", "internal/unsafeheader", - "io", - "io/fs", "math", "math/bits", - "os", - "path", "runtime", "runtime/internal/atomic", "runtime/internal/math", "runtime/internal/sys", "runtime/internal/syscall", - "sort", "strconv", "sync", "sync/atomic", - "syscall", - "time", "unicode/utf8", "unsafe" ] @@ -2520,8 +2782,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -2542,10 +2806,13 @@ "context", "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -2593,9 +2860,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2639,8 +2908,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2685,9 +2956,12 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -2696,7 +2970,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rsa", @@ -2715,11 +2988,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -2771,7 +3047,7 @@ ] } { - "ImportPath": "vendor/golang.org/x/crypto/internal/subtle", + "ImportPath": "vendor/golang.org/x/crypto/internal/alias", "Standard": true, "Deps": [ "unsafe" @@ -2781,15 +3057,18 @@ "ImportPath": "vendor/golang.org/x/crypto/chacha20", "Standard": true, "Deps": [ + "bytes", "crypto/cipher", - "crypto/internal/subtle", + "crypto/internal/alias", "crypto/subtle", "encoding/binary", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2811,7 +3090,7 @@ "unicode", "unicode/utf8", "unsafe", - "vendor/golang.org/x/crypto/internal/subtle" + "vendor/golang.org/x/crypto/internal/alias" ] } { @@ -2823,8 +3102,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2855,8 +3136,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2895,8 +3178,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2912,6 +3197,7 @@ "io", "io/fs", "io/ioutil", + "math", "math/bits", "os", "path", @@ -2921,6 +3207,7 @@ "runtime/internal/sys", "runtime/internal/syscall", "sort", + "strconv", "strings", "sync", "sync/atomic", @@ -2935,15 +3222,18 @@ "ImportPath": "vendor/golang.org/x/crypto/chacha20poly1305", "Standard": true, "Deps": [ + "bytes", "crypto/cipher", - "crypto/internal/subtle", + "crypto/internal/alias", "crypto/subtle", "encoding/binary", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2980,112 +3270,32 @@ "unicode/utf8", "unsafe", "vendor/golang.org/x/crypto/chacha20", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/sys/cpu" ] } -{ - "ImportPath": "vendor/golang.org/x/crypto/curve25519/internal/field", - "Standard": true, - "Deps": [ - "crypto/subtle", - "encoding/binary", - "errors", - "internal/abi", - "internal/bytealg", - "internal/cpu", - "internal/goarch", - "internal/goexperiment", - "internal/goos", - "internal/itoa", - "internal/race", - "internal/reflectlite", - "internal/unsafeheader", - "io", - "math", - "math/bits", - "reflect", - "runtime", - "runtime/internal/atomic", - "runtime/internal/math", - "runtime/internal/sys", - "runtime/internal/syscall", - "strconv", - "sync", - "sync/atomic", - "unicode", - "unicode/utf8", - "unsafe" - ] -} -{ - "ImportPath": "vendor/golang.org/x/crypto/curve25519", - "Standard": true, - "Deps": [ - "crypto/subtle", - "encoding/binary", - "errors", - "fmt", - "internal/abi", - "internal/bytealg", - "internal/cpu", - "internal/fmtsort", - "internal/goarch", - "internal/goexperiment", - "internal/goos", - "internal/itoa", - "internal/oserror", - "internal/poll", - "internal/race", - "internal/reflectlite", - "internal/safefilepath", - "internal/syscall/execenv", - "internal/syscall/unix", - "internal/testlog", - "internal/unsafeheader", - "io", - "io/fs", - "math", - "math/bits", - "os", - "path", - "reflect", - "runtime", - "runtime/internal/atomic", - "runtime/internal/math", - "runtime/internal/sys", - "runtime/internal/syscall", - "sort", - "strconv", - "sync", - "sync/atomic", - "syscall", - "time", - "unicode", - "unicode/utf8", - "unsafe", - "vendor/golang.org/x/crypto/curve25519/internal/field" - ] -} { "ImportPath": "vendor/golang.org/x/crypto/hkdf", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", "crypto/hmac", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3121,10 +3331,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -3133,7 +3346,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -3154,11 +3366,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -3209,11 +3424,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/sys/cpu" ] @@ -3222,6 +3435,40 @@ "ImportPath": "encoding", "Standard": true } +{ + "ImportPath": "internal/saferio", + "Standard": true, + "Deps": [ + "errors", + "internal/abi", + "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/goarch", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/itoa", + "internal/race", + "internal/reflectlite", + "internal/unsafeheader", + "io", + "math", + "math/bits", + "reflect", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "strconv", + "sync", + "sync/atomic", + "unicode", + "unicode/utf8", + "unsafe" + ] +} { "ImportPath": "encoding/gob", "Standard": true, @@ -3234,9 +3481,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3245,6 +3494,7 @@ "internal/race", "internal/reflectlite", "internal/safefilepath", + "internal/saferio", "internal/syscall/execenv", "internal/syscall/unix", "internal/testlog", @@ -3285,9 +3535,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3336,9 +3588,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3384,9 +3638,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3430,8 +3686,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -3463,8 +3721,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -3509,9 +3769,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3568,8 +3830,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3617,9 +3881,11 @@ "golang.org/x/sys/unix", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3680,9 +3946,11 @@ "golang.org/x/sys/unix", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3729,6 +3997,10 @@ "GoVersion": "1.19" } } +{ + "ImportPath": "log/internal", + "Standard": true +} { "ImportPath": "log", "Standard": true, @@ -3737,9 +4009,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3754,6 +4028,7 @@ "internal/unsafeheader", "io", "io/fs", + "log/internal", "math", "math/bits", "os", @@ -3783,11 +4058,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -3806,6 +4084,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "net", @@ -3848,11 +4127,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -3871,6 +4153,7 @@ "io", "io/fs", "log", + "log/internal", "log/syslog", "math", "math/bits", @@ -3916,9 +4199,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3974,9 +4259,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4040,9 +4327,11 @@ "gopkg.in/yaml.v2", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4090,9 +4379,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4138,9 +4429,11 @@ "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4189,9 +4482,11 @@ "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4236,19 +4531,24 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", "internal/reflectlite", "internal/unsafeheader", "io", + "math", + "math/bits", "runtime", "runtime/internal/atomic", "runtime/internal/math", "runtime/internal/sys", "runtime/internal/syscall", + "strconv", "strings", "sync", "sync/atomic", @@ -4266,9 +4566,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4313,8 +4615,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4365,9 +4669,11 @@ "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4420,9 +4726,11 @@ "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4468,14 +4776,17 @@ "errors", "fmt", "go/ast", + "go/build/constraint", "go/internal/typeparams", "go/scanner", "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4521,9 +4832,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4569,10 +4882,13 @@ "context", "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4617,10 +4933,13 @@ "context", "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4662,6 +4981,10 @@ "ImportPath": "internal/goversion", "Standard": true } +{ + "ImportPath": "internal/platform", + "Standard": true +} { "ImportPath": "go/build", "Standard": true, @@ -4680,12 +5003,15 @@ "go/scanner", "go/token", "internal/abi", + "internal/bisect", "internal/buildcfg", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/goroot", @@ -4693,6 +5019,7 @@ "internal/itoa", "internal/lazyregexp", "internal/oserror", + "internal/platform", "internal/poll", "internal/race", "internal/reflectlite", @@ -4746,11 +5073,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4797,8 +5127,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -4827,9 +5159,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4845,6 +5179,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "os", @@ -4876,9 +5211,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4894,6 +5231,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "os", @@ -4927,9 +5265,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4977,9 +5317,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4995,6 +5337,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "os", @@ -5031,11 +5374,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5091,11 +5437,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5114,6 +5463,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "net", @@ -5157,11 +5507,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5180,6 +5533,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "net", @@ -5221,9 +5575,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -5271,9 +5627,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -5320,9 +5678,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -5368,10 +5728,10 @@ "context", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/rand", "crypto/subtle", "encoding/base64", @@ -5380,11 +5740,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5447,10 +5810,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -5459,7 +5825,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -5481,11 +5846,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5537,11 +5905,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/sys/cpu" ] @@ -5556,9 +5922,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -5602,8 +5970,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -5638,10 +6008,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -5650,7 +6023,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -5673,11 +6045,14 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5697,6 +6072,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -5736,11 +6112,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -5776,10 +6150,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -5788,7 +6165,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -5815,11 +6191,14 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5839,6 +6218,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -5882,11 +6262,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -5926,10 +6304,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -5938,7 +6319,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -5980,12 +6360,15 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/buildcfg", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/goroot", @@ -5995,6 +6378,7 @@ "internal/lazyregexp", "internal/nettrace", "internal/oserror", + "internal/platform", "internal/poll", "internal/race", "internal/reflectlite", @@ -6008,6 +6392,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "log/syslog", "math", "math/big", @@ -6052,11 +6437,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -6090,10 +6473,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -6102,7 +6488,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -6149,12 +6534,15 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/buildcfg", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/goroot", @@ -6164,6 +6552,7 @@ "internal/lazyregexp", "internal/nettrace", "internal/oserror", + "internal/platform", "internal/poll", "internal/race", "internal/reflectlite", @@ -6177,6 +6566,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "log/syslog", "math", "math/big", @@ -6221,11 +6611,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -6254,8 +6642,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6295,9 +6685,11 @@ "github.com/go-logr/logr", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6362,9 +6754,13 @@ "errors", "github.com/google/go-cmp/cmp/internal/flags", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6403,8 +6799,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6448,9 +6846,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6506,10 +6906,14 @@ "github.com/google/go-cmp/cmp/internal/function", "github.com/google/go-cmp/cmp/internal/value", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6565,9 +6969,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6625,9 +7031,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6686,9 +7094,11 @@ "github.com/onsi/ginkgo/v2/formatter", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6756,9 +7166,11 @@ "github.com/onsi/ginkgo/v2/types", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6807,8 +7219,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -6837,9 +7251,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6885,9 +7301,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6940,10 +7358,14 @@ "fmt", "html", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6965,6 +7387,8 @@ "path", "path/filepath", "reflect", + "regexp", + "regexp/syntax", "runtime", "runtime/internal/atomic", "runtime/internal/math", @@ -7000,10 +7424,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -7012,7 +7439,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -7041,11 +7467,14 @@ "html", "html/template", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -7056,6 +7485,7 @@ "internal/race", "internal/reflectlite", "internal/safefilepath", + "internal/saferio", "internal/singleflight", "internal/syscall/execenv", "internal/syscall/unix", @@ -7065,6 +7495,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -7084,6 +7515,8 @@ "path", "path/filepath", "reflect", + "regexp", + "regexp/syntax", "runtime", "runtime/cgo", "runtime/internal/atomic", @@ -7107,11 +7540,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -7146,10 +7577,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -7158,7 +7592,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -7193,11 +7626,14 @@ "html", "html/template", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -7208,6 +7644,7 @@ "internal/race", "internal/reflectlite", "internal/safefilepath", + "internal/saferio", "internal/singleflight", "internal/syscall/execenv", "internal/syscall/unix", @@ -7217,6 +7654,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -7263,11 +7701,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -7288,8 +7724,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -7343,10 +7781,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -7355,7 +7796,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -7391,11 +7831,14 @@ "html", "html/template", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -7406,6 +7849,7 @@ "internal/race", "internal/reflectlite", "internal/safefilepath", + "internal/saferio", "internal/singleflight", "internal/syscall/execenv", "internal/syscall/unix", @@ -7415,6 +7859,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -7462,11 +7907,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -7495,8 +7938,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -7538,10 +7983,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -7550,7 +7998,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -7591,11 +8038,14 @@ "html", "html/template", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -7606,6 +8056,7 @@ "internal/race", "internal/reflectlite", "internal/safefilepath", + "internal/saferio", "internal/singleflight", "internal/syscall/execenv", "internal/syscall/unix", @@ -7615,6 +8066,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -7662,11 +8114,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -7701,10 +8151,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -7713,7 +8166,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -7755,11 +8207,14 @@ "html", "html/template", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -7770,6 +8225,7 @@ "internal/race", "internal/reflectlite", "internal/safefilepath", + "internal/saferio", "internal/singleflight", "internal/syscall/execenv", "internal/syscall/unix", @@ -7779,6 +8235,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -7826,11 +8283,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -7865,10 +8320,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -7877,7 +8335,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -7919,11 +8376,14 @@ "html", "html/template", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -7934,6 +8394,7 @@ "internal/race", "internal/reflectlite", "internal/safefilepath", + "internal/saferio", "internal/singleflight", "internal/syscall/execenv", "internal/syscall/unix", @@ -7943,6 +8404,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -7990,11 +8452,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -8029,10 +8489,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -8041,7 +8504,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -8085,11 +8547,14 @@ "html", "html/template", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -8100,6 +8565,7 @@ "internal/race", "internal/reflectlite", "internal/safefilepath", + "internal/saferio", "internal/singleflight", "internal/syscall/execenv", "internal/syscall/unix", @@ -8109,6 +8575,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -8156,11 +8623,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -8189,9 +8654,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -8243,8 +8710,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -8282,9 +8751,11 @@ "github.com/onsi/gomega/types", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -8335,8 +8806,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -8428,9 +8901,11 @@ "github.com/onsi/gomega/matchers/support/goraph/util", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -8497,9 +8972,11 @@ "golang.org/x/net/html/atom", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -8564,8 +9041,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8602,8 +9081,10 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8644,8 +9125,10 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8687,8 +9170,10 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8730,8 +9215,10 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8773,8 +9260,10 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8816,8 +9305,10 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8859,8 +9350,10 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8911,8 +9404,10 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8953,8 +9448,10 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8991,8 +9488,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -9025,9 +9524,11 @@ "golang.org/x/text/internal/tag", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -9083,9 +9584,11 @@ "golang.org/x/text/internal/tag", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -9142,9 +9645,11 @@ "golang.org/x/text/internal/tag", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -9214,9 +9719,11 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -9293,9 +9800,11 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -9353,9 +9862,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -9401,8 +9912,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -9437,10 +9950,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -9449,7 +9965,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -9474,11 +9989,14 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -9498,6 +10016,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -9539,11 +10058,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -9578,10 +10095,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -9590,7 +10110,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -9650,11 +10169,14 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -9674,6 +10196,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -9718,11 +10241,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -9757,10 +10278,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -9769,7 +10293,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -9831,11 +10354,14 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -9855,6 +10381,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -9899,11 +10426,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -9922,8 +10447,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -9946,9 +10473,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -9995,10 +10524,14 @@ "flag", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", diff --git a/tests/unit/data/gomod-mocks/non-vendored/go_list_deps_threedot.json b/tests/unit/data/gomod-mocks/non-vendored/go_list_deps_threedot.json index 1f8feb1c5..29de7d643 100644 --- a/tests/unit/data/gomod-mocks/non-vendored/go_list_deps_threedot.json +++ b/tests/unit/data/gomod-mocks/non-vendored/go_list_deps_threedot.json @@ -7,17 +7,17 @@ "Standard": true } { - "ImportPath": "internal/unsafeheader", + "ImportPath": "internal/abi", "Standard": true, "Deps": [ + "internal/goarch", "unsafe" ] } { - "ImportPath": "internal/abi", + "ImportPath": "internal/unsafeheader", "Standard": true, "Deps": [ - "internal/goarch", "unsafe" ] } @@ -33,6 +33,14 @@ "unsafe" ] } +{ + "ImportPath": "internal/coverage/rtcov", + "Standard": true +} +{ + "ImportPath": "internal/godebugs", + "Standard": true +} { "ImportPath": "internal/goexperiment", "Standard": true @@ -76,8 +84,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "runtime/internal/atomic", @@ -93,8 +103,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/unsafeheader", @@ -112,8 +124,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -157,8 +171,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -194,8 +210,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -219,8 +237,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -248,8 +268,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -270,8 +292,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -302,8 +326,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -326,8 +352,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -347,8 +375,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -373,8 +403,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -400,8 +432,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -427,8 +461,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -457,8 +493,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -478,8 +516,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -504,8 +544,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -526,8 +568,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -548,8 +592,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -581,8 +627,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -620,9 +668,11 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -665,8 +715,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -692,8 +744,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -724,8 +778,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -761,8 +817,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -810,9 +868,11 @@ "golang.org/x/sys/unix", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -873,9 +933,11 @@ "golang.org/x/sys/unix", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -930,8 +992,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -958,8 +1022,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -984,8 +1050,10 @@ "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -1007,7 +1075,7 @@ ] } { - "ImportPath": "crypto/internal/subtle", + "ImportPath": "crypto/internal/alias", "Standard": true, "Deps": [ "unsafe" @@ -1021,14 +1089,17 @@ "ImportPath": "crypto/cipher", "Standard": true, "Deps": [ - "crypto/internal/subtle", + "bytes", + "crypto/internal/alias", "crypto/subtle", "encoding/binary", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1060,18 +1131,21 @@ "ImportPath": "crypto/internal/boring", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1099,19 +1173,22 @@ "ImportPath": "crypto/sha256", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1143,9 +1220,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1194,8 +1273,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1235,9 +1316,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1286,9 +1369,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1332,8 +1417,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -1365,8 +1452,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -1411,9 +1500,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1453,6 +1544,10 @@ "unsafe" ] } +{ + "ImportPath": "log/internal", + "Standard": true +} { "ImportPath": "log", "Standard": true, @@ -1461,9 +1556,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1478,6 +1575,7 @@ "internal/unsafeheader", "io", "io/fs", + "log/internal", "math", "math/bits", "os", @@ -1506,8 +1604,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1534,8 +1634,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -1548,43 +1650,50 @@ "unsafe" ] } +{ + "ImportPath": "internal/bisect", + "Standard": true, + "Deps": [ + "internal/abi", + "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/goarch", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/race", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "sync", + "sync/atomic", + "unsafe" + ] +} { "ImportPath": "internal/godebug", "Standard": true, "Deps": [ - "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", - "internal/itoa", - "internal/oserror", - "internal/poll", "internal/race", - "internal/reflectlite", - "internal/safefilepath", - "internal/syscall/execenv", - "internal/syscall/unix", - "internal/testlog", - "internal/unsafeheader", - "io", - "io/fs", - "math/bits", - "os", - "path", "runtime", "runtime/internal/atomic", "runtime/internal/math", "runtime/internal/sys", "runtime/internal/syscall", - "sort", "sync", "sync/atomic", - "syscall", - "time", - "unicode/utf8", "unsafe" ] } @@ -1598,8 +1707,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -1617,40 +1728,24 @@ "ImportPath": "internal/intern", "Standard": true, "Deps": [ - "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", - "internal/itoa", - "internal/oserror", - "internal/poll", "internal/race", - "internal/reflectlite", - "internal/safefilepath", - "internal/syscall/execenv", - "internal/syscall/unix", - "internal/testlog", - "internal/unsafeheader", - "io", - "io/fs", - "math/bits", - "os", - "path", "runtime", "runtime/internal/atomic", "runtime/internal/math", "runtime/internal/sys", "runtime/internal/syscall", - "sort", "sync", "sync/atomic", - "syscall", - "time", - "unicode/utf8", "unsafe" ] } @@ -1660,40 +1755,30 @@ "Deps": [ "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", "internal/itoa", - "internal/oserror", - "internal/poll", "internal/race", "internal/reflectlite", - "internal/safefilepath", - "internal/syscall/execenv", - "internal/syscall/unix", - "internal/testlog", "internal/unsafeheader", - "io", - "io/fs", "math", "math/bits", - "os", - "path", "runtime", "runtime/internal/atomic", "runtime/internal/math", "runtime/internal/sys", "runtime/internal/syscall", - "sort", "strconv", "sync", "sync/atomic", - "syscall", - "time", "unicode/utf8", "unsafe" ] @@ -1704,8 +1789,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -1726,10 +1813,13 @@ "context", "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -1777,11 +1867,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -1800,6 +1893,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "net", @@ -1833,8 +1927,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1884,11 +1980,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -1907,6 +2006,7 @@ "io", "io/fs", "log", + "log/internal", "log/syslog", "math", "math/bits", @@ -1952,9 +2052,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2010,9 +2112,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2076,9 +2180,11 @@ "gopkg.in/yaml.v2", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2126,9 +2232,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2174,9 +2282,11 @@ "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2225,9 +2335,11 @@ "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2272,19 +2384,24 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", "internal/reflectlite", "internal/unsafeheader", "io", + "math", + "math/bits", "runtime", "runtime/internal/atomic", "runtime/internal/math", "runtime/internal/sys", "runtime/internal/syscall", + "strconv", "strings", "sync", "sync/atomic", @@ -2302,9 +2419,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2349,8 +2468,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2401,9 +2522,11 @@ "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2456,9 +2579,11 @@ "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2504,14 +2629,17 @@ "errors", "fmt", "go/ast", + "go/build/constraint", "go/internal/typeparams", "go/scanner", "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2557,9 +2685,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2605,10 +2735,13 @@ "context", "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2653,10 +2786,13 @@ "context", "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2698,6 +2834,10 @@ "ImportPath": "internal/goversion", "Standard": true } +{ + "ImportPath": "internal/platform", + "Standard": true +} { "ImportPath": "go/build", "Standard": true, @@ -2716,12 +2856,15 @@ "go/scanner", "go/token", "internal/abi", + "internal/bisect", "internal/buildcfg", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/goroot", @@ -2729,6 +2872,7 @@ "internal/itoa", "internal/lazyregexp", "internal/oserror", + "internal/platform", "internal/poll", "internal/race", "internal/reflectlite", @@ -2782,11 +2926,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2832,8 +2979,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2875,9 +3024,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2922,8 +3073,10 @@ "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -2954,9 +3107,11 @@ "hash/crc32", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3004,8 +3159,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -3027,9 +3184,13 @@ "Standard": true, "Deps": [ "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -3054,10 +3215,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3102,20 +3267,24 @@ "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3158,19 +3327,22 @@ "ImportPath": "crypto/aes", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3198,15 +3370,54 @@ "ImportPath": "crypto/des", "Standard": true, "Deps": [ + "bytes", "crypto/cipher", - "crypto/internal/subtle", + "crypto/internal/alias", + "crypto/subtle", + "encoding/binary", + "errors", + "internal/abi", + "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/goarch", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/itoa", + "internal/race", + "internal/reflectlite", + "internal/unsafeheader", + "io", + "math", + "math/bits", + "reflect", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "strconv", + "sync", + "sync/atomic", + "unicode", + "unicode/utf8", + "unsafe" + ] +} +{ + "ImportPath": "crypto/internal/edwards25519/field", + "Standard": true, + "Deps": [ "crypto/subtle", "encoding/binary", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3238,8 +3449,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -3260,8 +3473,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3298,8 +3513,64 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/goarch", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/itoa", + "internal/oserror", + "internal/race", + "internal/reflectlite", + "internal/unsafeheader", + "io", + "io/fs", + "math", + "math/bits", + "path", + "reflect", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "sort", + "strconv", + "sync", + "sync/atomic", + "syscall", + "time", + "unicode", + "unicode/utf8", + "unsafe" + ] +} +{ + "ImportPath": "crypto/ecdh", + "Standard": true, + "Deps": [ + "bytes", + "crypto", + "crypto/cipher", + "crypto/internal/alias", + "crypto/internal/boring", + "crypto/internal/boring/sig", + "crypto/internal/edwards25519/field", + "crypto/internal/nistec", + "crypto/internal/nistec/fiat", + "crypto/internal/randutil", + "crypto/subtle", + "embed", + "encoding/binary", + "errors", + "hash", + "internal/abi", + "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3342,10 +3613,69 @@ "errors", "fmt", "internal/abi", + "internal/bisect", + "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/fmtsort", + "internal/goarch", + "internal/godebug", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/itoa", + "internal/oserror", + "internal/poll", + "internal/race", + "internal/reflectlite", + "internal/safefilepath", + "internal/syscall/execenv", + "internal/syscall/unix", + "internal/testlog", + "internal/unsafeheader", + "io", + "io/fs", + "math", + "math/big", + "math/bits", + "math/rand", + "os", + "path", + "reflect", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "sort", + "strconv", + "strings", + "sync", + "sync/atomic", + "syscall", + "time", + "unicode", + "unicode/utf8", + "unsafe" + ] +} +{ + "ImportPath": "crypto/internal/bigmod", + "Standard": true, + "Deps": [ + "bytes", + "encoding/binary", + "errors", + "fmt", + "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3391,19 +3721,23 @@ "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3446,19 +3780,22 @@ "ImportPath": "crypto/sha512", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3491,10 +3828,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3548,10 +3889,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3600,14 +3945,17 @@ "crypto", "crypto/aes", "crypto/cipher", + "crypto/ecdh", "crypto/elliptic", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", + "crypto/internal/edwards25519/field", "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/sha512", "crypto/subtle", "embed", @@ -3617,10 +3965,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3662,40 +4014,6 @@ "vendor/golang.org/x/crypto/cryptobyte/asn1" ] } -{ - "ImportPath": "crypto/internal/edwards25519/field", - "Standard": true, - "Deps": [ - "crypto/subtle", - "encoding/binary", - "errors", - "internal/abi", - "internal/bytealg", - "internal/cpu", - "internal/goarch", - "internal/goexperiment", - "internal/goos", - "internal/itoa", - "internal/race", - "internal/reflectlite", - "internal/unsafeheader", - "io", - "math", - "math/bits", - "reflect", - "runtime", - "runtime/internal/atomic", - "runtime/internal/math", - "runtime/internal/sys", - "runtime/internal/syscall", - "strconv", - "sync", - "sync/atomic", - "unicode", - "unicode/utf8", - "unsafe" - ] -} { "ImportPath": "crypto/internal/edwards25519", "Standard": true, @@ -3706,8 +4024,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3738,12 +4058,12 @@ "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", "crypto/internal/edwards25519", "crypto/internal/edwards25519/field", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/rand", "crypto/sha512", "crypto/subtle", @@ -3752,10 +4072,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3798,19 +4122,22 @@ "ImportPath": "crypto/hmac", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3844,8 +4171,10 @@ "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3873,12 +4202,14 @@ "ImportPath": "crypto/rc4", "Standard": true, "Deps": [ - "crypto/internal/subtle", + "crypto/internal/alias", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -3902,11 +4233,12 @@ "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/rand", "crypto/subtle", "encoding/binary", @@ -3914,10 +4246,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3960,19 +4296,22 @@ "ImportPath": "crypto/sha1", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4006,10 +4345,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4059,10 +4402,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4112,8 +4459,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4147,9 +4496,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4197,9 +4548,12 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -4208,7 +4562,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rsa", @@ -4227,11 +4580,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -4283,7 +4639,7 @@ ] } { - "ImportPath": "vendor/golang.org/x/crypto/internal/subtle", + "ImportPath": "vendor/golang.org/x/crypto/internal/alias", "Standard": true, "Deps": [ "unsafe" @@ -4293,15 +4649,18 @@ "ImportPath": "vendor/golang.org/x/crypto/chacha20", "Standard": true, "Deps": [ + "bytes", "crypto/cipher", - "crypto/internal/subtle", + "crypto/internal/alias", "crypto/subtle", "encoding/binary", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4323,7 +4682,7 @@ "unicode", "unicode/utf8", "unsafe", - "vendor/golang.org/x/crypto/internal/subtle" + "vendor/golang.org/x/crypto/internal/alias" ] } { @@ -4335,8 +4694,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4367,8 +4728,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4384,6 +4747,7 @@ "io", "io/fs", "io/ioutil", + "math", "math/bits", "os", "path", @@ -4393,6 +4757,7 @@ "runtime/internal/sys", "runtime/internal/syscall", "sort", + "strconv", "strings", "sync", "sync/atomic", @@ -4407,15 +4772,18 @@ "ImportPath": "vendor/golang.org/x/crypto/chacha20poly1305", "Standard": true, "Deps": [ + "bytes", "crypto/cipher", - "crypto/internal/subtle", + "crypto/internal/alias", "crypto/subtle", "encoding/binary", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4452,112 +4820,32 @@ "unicode/utf8", "unsafe", "vendor/golang.org/x/crypto/chacha20", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/sys/cpu" ] } -{ - "ImportPath": "vendor/golang.org/x/crypto/curve25519/internal/field", - "Standard": true, - "Deps": [ - "crypto/subtle", - "encoding/binary", - "errors", - "internal/abi", - "internal/bytealg", - "internal/cpu", - "internal/goarch", - "internal/goexperiment", - "internal/goos", - "internal/itoa", - "internal/race", - "internal/reflectlite", - "internal/unsafeheader", - "io", - "math", - "math/bits", - "reflect", - "runtime", - "runtime/internal/atomic", - "runtime/internal/math", - "runtime/internal/sys", - "runtime/internal/syscall", - "strconv", - "sync", - "sync/atomic", - "unicode", - "unicode/utf8", - "unsafe" - ] -} -{ - "ImportPath": "vendor/golang.org/x/crypto/curve25519", - "Standard": true, - "Deps": [ - "crypto/subtle", - "encoding/binary", - "errors", - "fmt", - "internal/abi", - "internal/bytealg", - "internal/cpu", - "internal/fmtsort", - "internal/goarch", - "internal/goexperiment", - "internal/goos", - "internal/itoa", - "internal/oserror", - "internal/poll", - "internal/race", - "internal/reflectlite", - "internal/safefilepath", - "internal/syscall/execenv", - "internal/syscall/unix", - "internal/testlog", - "internal/unsafeheader", - "io", - "io/fs", - "math", - "math/bits", - "os", - "path", - "reflect", - "runtime", - "runtime/internal/atomic", - "runtime/internal/math", - "runtime/internal/sys", - "runtime/internal/syscall", - "sort", - "strconv", - "sync", - "sync/atomic", - "syscall", - "time", - "unicode", - "unicode/utf8", - "unsafe", - "vendor/golang.org/x/crypto/curve25519/internal/field" - ] -} { "ImportPath": "vendor/golang.org/x/crypto/hkdf", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", "crypto/hmac", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4593,10 +4881,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -4605,7 +4896,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -4626,11 +4916,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -4681,11 +4974,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/sys/cpu" ] @@ -4698,8 +4989,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -4728,9 +5021,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4746,6 +5041,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "os", @@ -4777,9 +5073,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4795,6 +5093,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "os", @@ -4828,9 +5127,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4878,9 +5179,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4896,6 +5199,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "os", @@ -4932,11 +5236,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -4992,11 +5299,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5015,6 +5325,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "net", @@ -5058,11 +5369,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5081,6 +5395,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "net", @@ -5122,9 +5437,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -5172,9 +5489,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -5221,9 +5540,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -5269,10 +5590,10 @@ "context", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/rand", "crypto/subtle", "encoding/base64", @@ -5281,11 +5602,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5348,10 +5672,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -5360,7 +5687,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -5382,11 +5708,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5438,11 +5767,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/sys/cpu" ] @@ -5457,9 +5784,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -5503,8 +5832,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -5539,10 +5870,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -5551,7 +5885,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -5574,11 +5907,14 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5598,6 +5934,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -5637,11 +5974,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -5677,10 +6012,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -5689,7 +6027,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -5716,11 +6053,14 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5740,6 +6080,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -5783,11 +6124,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -5827,10 +6166,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -5839,7 +6181,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -5881,12 +6222,15 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/buildcfg", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/goroot", @@ -5896,6 +6240,7 @@ "internal/lazyregexp", "internal/nettrace", "internal/oserror", + "internal/platform", "internal/poll", "internal/race", "internal/reflectlite", @@ -5909,6 +6254,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "log/syslog", "math", "math/big", @@ -5953,11 +6299,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -5991,10 +6335,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -6003,7 +6350,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -6050,12 +6396,15 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/buildcfg", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/goroot", @@ -6065,6 +6414,7 @@ "internal/lazyregexp", "internal/nettrace", "internal/oserror", + "internal/platform", "internal/poll", "internal/race", "internal/reflectlite", @@ -6078,6 +6428,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "log/syslog", "math", "math/big", @@ -6122,11 +6473,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", diff --git a/tests/unit/data/gomod-mocks/vendored/go_list_deps_all.json b/tests/unit/data/gomod-mocks/vendored/go_list_deps_all.json index 5df3c9d3e..2f338504d 100644 --- a/tests/unit/data/gomod-mocks/vendored/go_list_deps_all.json +++ b/tests/unit/data/gomod-mocks/vendored/go_list_deps_all.json @@ -7,17 +7,17 @@ "Standard": true } { - "ImportPath": "internal/unsafeheader", + "ImportPath": "internal/abi", "Standard": true, "Deps": [ + "internal/goarch", "unsafe" ] } { - "ImportPath": "internal/abi", + "ImportPath": "internal/unsafeheader", "Standard": true, "Deps": [ - "internal/goarch", "unsafe" ] } @@ -33,6 +33,14 @@ "unsafe" ] } +{ + "ImportPath": "internal/coverage/rtcov", + "Standard": true +} +{ + "ImportPath": "internal/godebugs", + "Standard": true +} { "ImportPath": "internal/goexperiment", "Standard": true @@ -76,8 +84,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "runtime/internal/atomic", @@ -93,8 +103,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/unsafeheader", @@ -112,8 +124,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -146,8 +160,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -167,8 +183,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -199,8 +217,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -226,8 +246,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -254,8 +276,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -302,8 +326,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -326,8 +352,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -355,8 +383,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -377,8 +407,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -409,8 +441,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -430,8 +464,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -456,8 +492,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -483,8 +521,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -510,8 +550,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -540,8 +582,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -561,8 +605,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -587,8 +633,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -609,8 +657,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -631,8 +681,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -664,8 +716,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -703,9 +757,11 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -751,9 +807,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -797,8 +855,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -829,8 +889,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -855,8 +917,10 @@ "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -887,9 +951,11 @@ "hash/crc32", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -937,8 +1003,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -966,8 +1034,10 @@ "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -989,7 +1059,7 @@ ] } { - "ImportPath": "crypto/internal/subtle", + "ImportPath": "crypto/internal/alias", "Standard": true, "Deps": [ "unsafe" @@ -1003,14 +1073,17 @@ "ImportPath": "crypto/cipher", "Standard": true, "Deps": [ - "crypto/internal/subtle", + "bytes", + "crypto/internal/alias", "crypto/subtle", "encoding/binary", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1042,18 +1115,21 @@ "ImportPath": "crypto/internal/boring", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1081,19 +1157,22 @@ "ImportPath": "crypto/aes", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1121,15 +1200,18 @@ "ImportPath": "crypto/des", "Standard": true, "Deps": [ + "bytes", "crypto/cipher", - "crypto/internal/subtle", + "crypto/internal/alias", "crypto/subtle", "encoding/binary", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1160,8 +1242,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -1178,14 +1262,65 @@ "unsafe" ] } +{ + "ImportPath": "internal/bisect", + "Standard": true, + "Deps": [ + "internal/abi", + "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/goarch", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/race", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "sync", + "sync/atomic", + "unsafe" + ] +} +{ + "ImportPath": "internal/godebug", + "Standard": true, + "Deps": [ + "internal/abi", + "internal/bisect", + "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/goarch", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/race", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "sync", + "sync/atomic", + "unsafe" + ] +} { "ImportPath": "math/rand", "Standard": true, "Deps": [ "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -1210,10 +1345,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1261,10 +1400,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1303,6 +1446,42 @@ "unsafe" ] } +{ + "ImportPath": "crypto/internal/edwards25519/field", + "Standard": true, + "Deps": [ + "crypto/subtle", + "encoding/binary", + "errors", + "internal/abi", + "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/goarch", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/itoa", + "internal/race", + "internal/reflectlite", + "internal/unsafeheader", + "io", + "math", + "math/bits", + "reflect", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "strconv", + "sync", + "sync/atomic", + "unicode", + "unicode/utf8", + "unsafe" + ] +} { "ImportPath": "crypto/internal/nistec/fiat", "Standard": true, @@ -1311,8 +1490,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -1333,8 +1514,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1371,8 +1554,64 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/itoa", + "internal/oserror", + "internal/race", + "internal/reflectlite", + "internal/unsafeheader", + "io", + "io/fs", + "math", + "math/bits", + "path", + "reflect", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "sort", + "strconv", + "sync", + "sync/atomic", + "syscall", + "time", + "unicode", + "unicode/utf8", + "unsafe" + ] +} +{ + "ImportPath": "crypto/ecdh", + "Standard": true, + "Deps": [ + "bytes", + "crypto", + "crypto/cipher", + "crypto/internal/alias", + "crypto/internal/boring", + "crypto/internal/boring/sig", + "crypto/internal/edwards25519/field", + "crypto/internal/nistec", + "crypto/internal/nistec/fiat", + "crypto/internal/randutil", + "crypto/subtle", + "embed", + "encoding/binary", + "errors", + "hash", + "internal/abi", + "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1415,10 +1654,69 @@ "errors", "fmt", "internal/abi", + "internal/bisect", + "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/fmtsort", + "internal/goarch", + "internal/godebug", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/itoa", + "internal/oserror", + "internal/poll", + "internal/race", + "internal/reflectlite", + "internal/safefilepath", + "internal/syscall/execenv", + "internal/syscall/unix", + "internal/testlog", + "internal/unsafeheader", + "io", + "io/fs", + "math", + "math/big", + "math/bits", + "math/rand", + "os", + "path", + "reflect", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "sort", + "strconv", + "strings", + "sync", + "sync/atomic", + "syscall", + "time", + "unicode", + "unicode/utf8", + "unsafe" + ] +} +{ + "ImportPath": "crypto/internal/bigmod", + "Standard": true, + "Deps": [ + "bytes", + "encoding/binary", + "errors", + "fmt", + "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1464,19 +1762,23 @@ "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1519,19 +1821,22 @@ "ImportPath": "crypto/sha512", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1568,10 +1873,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1625,10 +1934,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1677,14 +1990,17 @@ "crypto", "crypto/aes", "crypto/cipher", + "crypto/ecdh", "crypto/elliptic", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", + "crypto/internal/edwards25519/field", "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/sha512", "crypto/subtle", "embed", @@ -1694,10 +2010,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1739,40 +2059,6 @@ "vendor/golang.org/x/crypto/cryptobyte/asn1" ] } -{ - "ImportPath": "crypto/internal/edwards25519/field", - "Standard": true, - "Deps": [ - "crypto/subtle", - "encoding/binary", - "errors", - "internal/abi", - "internal/bytealg", - "internal/cpu", - "internal/goarch", - "internal/goexperiment", - "internal/goos", - "internal/itoa", - "internal/race", - "internal/reflectlite", - "internal/unsafeheader", - "io", - "math", - "math/bits", - "reflect", - "runtime", - "runtime/internal/atomic", - "runtime/internal/math", - "runtime/internal/sys", - "runtime/internal/syscall", - "strconv", - "sync", - "sync/atomic", - "unicode", - "unicode/utf8", - "unsafe" - ] -} { "ImportPath": "crypto/internal/edwards25519", "Standard": true, @@ -1783,8 +2069,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1815,20 +2103,24 @@ "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1874,12 +2166,12 @@ "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", "crypto/internal/edwards25519", "crypto/internal/edwards25519/field", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/rand", "crypto/sha512", "crypto/subtle", @@ -1888,10 +2180,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1934,19 +2230,22 @@ "ImportPath": "crypto/hmac", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1980,8 +2279,10 @@ "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2009,12 +2310,14 @@ "ImportPath": "crypto/rc4", "Standard": true, "Deps": [ - "crypto/internal/subtle", + "crypto/internal/alias", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -2038,11 +2341,12 @@ "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/rand", "crypto/subtle", "encoding/binary", @@ -2050,10 +2354,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2096,19 +2404,22 @@ "ImportPath": "crypto/sha1", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2136,19 +2447,22 @@ "ImportPath": "crypto/sha256", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2180,9 +2494,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2230,10 +2546,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2281,8 +2601,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2316,8 +2638,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2343,46 +2667,6 @@ "unsafe" ] } -{ - "ImportPath": "internal/godebug", - "Standard": true, - "Deps": [ - "errors", - "internal/abi", - "internal/bytealg", - "internal/cpu", - "internal/goarch", - "internal/goexperiment", - "internal/goos", - "internal/itoa", - "internal/oserror", - "internal/poll", - "internal/race", - "internal/reflectlite", - "internal/safefilepath", - "internal/syscall/execenv", - "internal/syscall/unix", - "internal/testlog", - "internal/unsafeheader", - "io", - "io/fs", - "math/bits", - "os", - "path", - "runtime", - "runtime/internal/atomic", - "runtime/internal/math", - "runtime/internal/sys", - "runtime/internal/syscall", - "sort", - "sync", - "sync/atomic", - "syscall", - "time", - "unicode/utf8", - "unsafe" - ] -} { "ImportPath": "vendor/golang.org/x/net/dns/dnsmessage", "Standard": true, @@ -2390,8 +2674,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -2414,8 +2700,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -2433,40 +2721,24 @@ "ImportPath": "internal/intern", "Standard": true, "Deps": [ - "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", - "internal/itoa", - "internal/oserror", - "internal/poll", "internal/race", - "internal/reflectlite", - "internal/safefilepath", - "internal/syscall/execenv", - "internal/syscall/unix", - "internal/testlog", - "internal/unsafeheader", - "io", - "io/fs", - "math/bits", - "os", - "path", "runtime", "runtime/internal/atomic", "runtime/internal/math", "runtime/internal/sys", "runtime/internal/syscall", - "sort", "sync", "sync/atomic", - "syscall", - "time", - "unicode/utf8", "unsafe" ] } @@ -2476,40 +2748,30 @@ "Deps": [ "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", "internal/itoa", - "internal/oserror", - "internal/poll", "internal/race", "internal/reflectlite", - "internal/safefilepath", - "internal/syscall/execenv", - "internal/syscall/unix", - "internal/testlog", "internal/unsafeheader", - "io", - "io/fs", "math", "math/bits", - "os", - "path", "runtime", "runtime/internal/atomic", "runtime/internal/math", "runtime/internal/sys", "runtime/internal/syscall", - "sort", "strconv", "sync", "sync/atomic", - "syscall", - "time", "unicode/utf8", "unsafe" ] @@ -2520,8 +2782,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -2542,10 +2806,13 @@ "context", "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -2593,9 +2860,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2639,8 +2908,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2685,9 +2956,12 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -2696,7 +2970,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rsa", @@ -2715,11 +2988,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -2771,7 +3047,7 @@ ] } { - "ImportPath": "vendor/golang.org/x/crypto/internal/subtle", + "ImportPath": "vendor/golang.org/x/crypto/internal/alias", "Standard": true, "Deps": [ "unsafe" @@ -2781,15 +3057,18 @@ "ImportPath": "vendor/golang.org/x/crypto/chacha20", "Standard": true, "Deps": [ + "bytes", "crypto/cipher", - "crypto/internal/subtle", + "crypto/internal/alias", "crypto/subtle", "encoding/binary", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2811,7 +3090,7 @@ "unicode", "unicode/utf8", "unsafe", - "vendor/golang.org/x/crypto/internal/subtle" + "vendor/golang.org/x/crypto/internal/alias" ] } { @@ -2823,8 +3102,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2855,8 +3136,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2895,8 +3178,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2912,6 +3197,7 @@ "io", "io/fs", "io/ioutil", + "math", "math/bits", "os", "path", @@ -2921,6 +3207,7 @@ "runtime/internal/sys", "runtime/internal/syscall", "sort", + "strconv", "strings", "sync", "sync/atomic", @@ -2935,15 +3222,18 @@ "ImportPath": "vendor/golang.org/x/crypto/chacha20poly1305", "Standard": true, "Deps": [ + "bytes", "crypto/cipher", - "crypto/internal/subtle", + "crypto/internal/alias", "crypto/subtle", "encoding/binary", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2980,112 +3270,32 @@ "unicode/utf8", "unsafe", "vendor/golang.org/x/crypto/chacha20", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/sys/cpu" ] } -{ - "ImportPath": "vendor/golang.org/x/crypto/curve25519/internal/field", - "Standard": true, - "Deps": [ - "crypto/subtle", - "encoding/binary", - "errors", - "internal/abi", - "internal/bytealg", - "internal/cpu", - "internal/goarch", - "internal/goexperiment", - "internal/goos", - "internal/itoa", - "internal/race", - "internal/reflectlite", - "internal/unsafeheader", - "io", - "math", - "math/bits", - "reflect", - "runtime", - "runtime/internal/atomic", - "runtime/internal/math", - "runtime/internal/sys", - "runtime/internal/syscall", - "strconv", - "sync", - "sync/atomic", - "unicode", - "unicode/utf8", - "unsafe" - ] -} -{ - "ImportPath": "vendor/golang.org/x/crypto/curve25519", - "Standard": true, - "Deps": [ - "crypto/subtle", - "encoding/binary", - "errors", - "fmt", - "internal/abi", - "internal/bytealg", - "internal/cpu", - "internal/fmtsort", - "internal/goarch", - "internal/goexperiment", - "internal/goos", - "internal/itoa", - "internal/oserror", - "internal/poll", - "internal/race", - "internal/reflectlite", - "internal/safefilepath", - "internal/syscall/execenv", - "internal/syscall/unix", - "internal/testlog", - "internal/unsafeheader", - "io", - "io/fs", - "math", - "math/bits", - "os", - "path", - "reflect", - "runtime", - "runtime/internal/atomic", - "runtime/internal/math", - "runtime/internal/sys", - "runtime/internal/syscall", - "sort", - "strconv", - "sync", - "sync/atomic", - "syscall", - "time", - "unicode", - "unicode/utf8", - "unsafe", - "vendor/golang.org/x/crypto/curve25519/internal/field" - ] -} { "ImportPath": "vendor/golang.org/x/crypto/hkdf", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", "crypto/hmac", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3121,10 +3331,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -3133,7 +3346,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -3154,11 +3366,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -3209,11 +3424,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/sys/cpu" ] @@ -3222,6 +3435,40 @@ "ImportPath": "encoding", "Standard": true } +{ + "ImportPath": "internal/saferio", + "Standard": true, + "Deps": [ + "errors", + "internal/abi", + "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/goarch", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/itoa", + "internal/race", + "internal/reflectlite", + "internal/unsafeheader", + "io", + "math", + "math/bits", + "reflect", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "strconv", + "sync", + "sync/atomic", + "unicode", + "unicode/utf8", + "unsafe" + ] +} { "ImportPath": "encoding/gob", "Standard": true, @@ -3234,9 +3481,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3245,6 +3494,7 @@ "internal/race", "internal/reflectlite", "internal/safefilepath", + "internal/saferio", "internal/syscall/execenv", "internal/syscall/unix", "internal/testlog", @@ -3285,9 +3535,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3336,9 +3588,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3384,9 +3638,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3430,8 +3686,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -3463,8 +3721,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -3506,9 +3766,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3562,8 +3824,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3608,9 +3872,11 @@ "golang.org/x/sys/unix", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3669,9 +3935,11 @@ "golang.org/x/sys/unix", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3718,6 +3986,10 @@ "GoVersion": "1.19" } } +{ + "ImportPath": "log/internal", + "Standard": true +} { "ImportPath": "log", "Standard": true, @@ -3726,9 +3998,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3743,6 +4017,7 @@ "internal/unsafeheader", "io", "io/fs", + "log/internal", "math", "math/bits", "os", @@ -3772,11 +4047,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -3795,6 +4073,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "net", @@ -3834,11 +4113,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -3857,6 +4139,7 @@ "io", "io/fs", "log", + "log/internal", "log/syslog", "math", "math/bits", @@ -3899,9 +4182,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3954,9 +4239,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4015,9 +4302,11 @@ "gopkg.in/yaml.v2", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4065,9 +4354,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4113,9 +4404,11 @@ "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4164,9 +4457,11 @@ "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4211,19 +4506,24 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", "internal/reflectlite", "internal/unsafeheader", "io", + "math", + "math/bits", "runtime", "runtime/internal/atomic", "runtime/internal/math", "runtime/internal/sys", "runtime/internal/syscall", + "strconv", "strings", "sync", "sync/atomic", @@ -4241,9 +4541,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4288,8 +4590,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4340,9 +4644,11 @@ "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4395,9 +4701,11 @@ "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4443,14 +4751,17 @@ "errors", "fmt", "go/ast", + "go/build/constraint", "go/internal/typeparams", "go/scanner", "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4496,9 +4807,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4544,10 +4857,13 @@ "context", "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4592,10 +4908,13 @@ "context", "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4637,6 +4956,10 @@ "ImportPath": "internal/goversion", "Standard": true } +{ + "ImportPath": "internal/platform", + "Standard": true +} { "ImportPath": "go/build", "Standard": true, @@ -4655,12 +4978,15 @@ "go/scanner", "go/token", "internal/abi", + "internal/bisect", "internal/buildcfg", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/goroot", @@ -4668,6 +4994,7 @@ "internal/itoa", "internal/lazyregexp", "internal/oserror", + "internal/platform", "internal/poll", "internal/race", "internal/reflectlite", @@ -4718,11 +5045,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4769,8 +5099,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -4799,9 +5131,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4817,6 +5151,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "os", @@ -4848,9 +5183,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4866,6 +5203,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "os", @@ -4899,9 +5237,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4949,9 +5289,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4967,6 +5309,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "os", @@ -5003,11 +5346,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5063,11 +5409,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5086,6 +5435,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "net", @@ -5129,11 +5479,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5152,6 +5505,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "net", @@ -5193,9 +5547,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -5243,9 +5599,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -5292,9 +5650,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -5340,10 +5700,10 @@ "context", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/rand", "crypto/subtle", "encoding/base64", @@ -5352,11 +5712,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5419,10 +5782,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -5431,7 +5797,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -5453,11 +5818,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5509,11 +5877,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/sys/cpu" ] @@ -5528,9 +5894,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -5574,8 +5942,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -5610,10 +5980,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -5622,7 +5995,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -5645,11 +6017,14 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5669,6 +6044,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -5708,11 +6084,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -5745,10 +6119,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -5757,7 +6134,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -5784,11 +6160,14 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5808,6 +6187,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -5851,11 +6231,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -5890,10 +6268,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -5902,7 +6283,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -5944,12 +6324,15 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/buildcfg", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/goroot", @@ -5959,6 +6342,7 @@ "internal/lazyregexp", "internal/nettrace", "internal/oserror", + "internal/platform", "internal/poll", "internal/race", "internal/reflectlite", @@ -5972,6 +6356,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "log/syslog", "math", "math/big", @@ -6016,11 +6401,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -6054,10 +6437,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -6066,7 +6452,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -6113,12 +6498,15 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/buildcfg", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/goroot", @@ -6128,6 +6516,7 @@ "internal/lazyregexp", "internal/nettrace", "internal/oserror", + "internal/platform", "internal/poll", "internal/race", "internal/reflectlite", @@ -6141,6 +6530,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "log/syslog", "math", "math/big", @@ -6185,11 +6575,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -6215,8 +6603,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6253,9 +6643,11 @@ "github.com/go-logr/logr", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6314,9 +6706,13 @@ "errors", "github.com/google/go-cmp/cmp/internal/flags", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6352,8 +6748,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6394,9 +6792,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6449,10 +6849,14 @@ "github.com/google/go-cmp/cmp/internal/function", "github.com/google/go-cmp/cmp/internal/value", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6505,9 +6909,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6562,9 +6968,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6620,9 +7028,11 @@ "github.com/onsi/ginkgo/v2/formatter", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6687,9 +7097,11 @@ "github.com/onsi/ginkgo/v2/types", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6738,8 +7150,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -6768,9 +7182,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6816,9 +7232,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6871,10 +7289,14 @@ "fmt", "html", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -6896,6 +7318,8 @@ "path", "path/filepath", "reflect", + "regexp", + "regexp/syntax", "runtime", "runtime/internal/atomic", "runtime/internal/math", @@ -6931,10 +7355,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -6943,7 +7370,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -6972,11 +7398,14 @@ "html", "html/template", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -6987,6 +7416,7 @@ "internal/race", "internal/reflectlite", "internal/safefilepath", + "internal/saferio", "internal/singleflight", "internal/syscall/execenv", "internal/syscall/unix", @@ -6996,6 +7426,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -7015,6 +7446,8 @@ "path", "path/filepath", "reflect", + "regexp", + "regexp/syntax", "runtime", "runtime/cgo", "runtime/internal/atomic", @@ -7038,11 +7471,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -7074,10 +7505,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -7086,7 +7520,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -7121,11 +7554,14 @@ "html", "html/template", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -7136,6 +7572,7 @@ "internal/race", "internal/reflectlite", "internal/safefilepath", + "internal/saferio", "internal/singleflight", "internal/syscall/execenv", "internal/syscall/unix", @@ -7145,6 +7582,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -7191,11 +7629,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -7216,8 +7652,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -7268,10 +7706,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -7280,7 +7721,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -7316,11 +7756,14 @@ "html", "html/template", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -7331,6 +7774,7 @@ "internal/race", "internal/reflectlite", "internal/safefilepath", + "internal/saferio", "internal/singleflight", "internal/syscall/execenv", "internal/syscall/unix", @@ -7340,6 +7784,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -7387,11 +7832,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -7417,8 +7860,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -7457,10 +7902,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -7469,7 +7917,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -7510,11 +7957,14 @@ "html", "html/template", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -7525,6 +7975,7 @@ "internal/race", "internal/reflectlite", "internal/safefilepath", + "internal/saferio", "internal/singleflight", "internal/syscall/execenv", "internal/syscall/unix", @@ -7534,6 +7985,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -7581,11 +8033,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -7617,10 +8067,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -7629,7 +8082,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -7671,11 +8123,14 @@ "html", "html/template", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -7686,6 +8141,7 @@ "internal/race", "internal/reflectlite", "internal/safefilepath", + "internal/saferio", "internal/singleflight", "internal/syscall/execenv", "internal/syscall/unix", @@ -7695,6 +8151,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -7742,11 +8199,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -7778,10 +8233,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -7790,7 +8248,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -7832,11 +8289,14 @@ "html", "html/template", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -7847,6 +8307,7 @@ "internal/race", "internal/reflectlite", "internal/safefilepath", + "internal/saferio", "internal/singleflight", "internal/syscall/execenv", "internal/syscall/unix", @@ -7856,6 +8317,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -7903,11 +8365,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -7939,10 +8399,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -7951,7 +8414,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -7995,11 +8457,14 @@ "html", "html/template", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -8010,6 +8475,7 @@ "internal/race", "internal/reflectlite", "internal/safefilepath", + "internal/saferio", "internal/singleflight", "internal/syscall/execenv", "internal/syscall/unix", @@ -8019,6 +8485,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -8066,11 +8533,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -8096,9 +8561,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -8147,8 +8614,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -8183,9 +8652,11 @@ "github.com/onsi/gomega/types", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -8233,8 +8704,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -8314,9 +8787,11 @@ "github.com/onsi/gomega/matchers/support/goraph/util", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -8377,9 +8852,11 @@ "golang.org/x/net/html/atom", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -8438,8 +8915,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8473,8 +8952,10 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8512,8 +8993,10 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8552,8 +9035,10 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8592,8 +9077,10 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8632,8 +9119,10 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8672,8 +9161,10 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8712,8 +9203,10 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8758,8 +9251,10 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8797,8 +9292,10 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -8832,8 +9329,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -8863,9 +9362,11 @@ "golang.org/x/text/internal/tag", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -8918,9 +9419,11 @@ "golang.org/x/text/internal/tag", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -8974,9 +9477,11 @@ "golang.org/x/text/internal/tag", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -9043,9 +9548,11 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -9119,9 +9626,11 @@ "golang.org/x/text/transform", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -9176,9 +9685,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -9224,8 +9735,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -9260,10 +9773,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -9272,7 +9788,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -9297,11 +9812,14 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -9321,6 +9839,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -9362,11 +9881,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -9398,10 +9915,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -9410,7 +9930,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -9470,11 +9989,14 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -9494,6 +10016,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -9538,11 +10061,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -9574,10 +10095,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -9586,7 +10110,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -9648,11 +10171,14 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -9672,6 +10198,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -9716,11 +10243,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -9739,8 +10264,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -9763,9 +10290,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -9812,10 +10341,14 @@ "flag", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", diff --git a/tests/unit/data/gomod-mocks/vendored/go_list_deps_threedot.json b/tests/unit/data/gomod-mocks/vendored/go_list_deps_threedot.json index 9b4628f43..7ac680a2a 100644 --- a/tests/unit/data/gomod-mocks/vendored/go_list_deps_threedot.json +++ b/tests/unit/data/gomod-mocks/vendored/go_list_deps_threedot.json @@ -7,17 +7,17 @@ "Standard": true } { - "ImportPath": "internal/unsafeheader", + "ImportPath": "internal/abi", "Standard": true, "Deps": [ + "internal/goarch", "unsafe" ] } { - "ImportPath": "internal/abi", + "ImportPath": "internal/unsafeheader", "Standard": true, "Deps": [ - "internal/goarch", "unsafe" ] } @@ -33,6 +33,14 @@ "unsafe" ] } +{ + "ImportPath": "internal/coverage/rtcov", + "Standard": true +} +{ + "ImportPath": "internal/godebugs", + "Standard": true +} { "ImportPath": "internal/goexperiment", "Standard": true @@ -76,8 +84,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "runtime/internal/atomic", @@ -93,8 +103,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/unsafeheader", @@ -112,8 +124,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -157,8 +171,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -194,8 +210,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -219,8 +237,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -248,8 +268,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -270,8 +292,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -302,8 +326,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -326,8 +352,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -347,8 +375,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -373,8 +403,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -400,8 +432,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -427,8 +461,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -457,8 +493,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -478,8 +516,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -504,8 +544,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -526,8 +568,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -548,8 +592,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -581,8 +627,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -620,9 +668,11 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -665,8 +715,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -692,8 +744,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -724,8 +778,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -758,8 +814,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -804,9 +862,11 @@ "golang.org/x/sys/unix", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -865,9 +925,11 @@ "golang.org/x/sys/unix", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -922,8 +984,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -950,8 +1014,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -976,8 +1042,10 @@ "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -999,7 +1067,7 @@ ] } { - "ImportPath": "crypto/internal/subtle", + "ImportPath": "crypto/internal/alias", "Standard": true, "Deps": [ "unsafe" @@ -1013,14 +1081,17 @@ "ImportPath": "crypto/cipher", "Standard": true, "Deps": [ - "crypto/internal/subtle", + "bytes", + "crypto/internal/alias", "crypto/subtle", "encoding/binary", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1052,18 +1123,21 @@ "ImportPath": "crypto/internal/boring", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1091,19 +1165,22 @@ "ImportPath": "crypto/sha256", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1135,9 +1212,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1186,8 +1265,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1227,9 +1308,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1278,9 +1361,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1324,8 +1409,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -1357,8 +1444,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -1400,9 +1489,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1442,6 +1533,10 @@ "unsafe" ] } +{ + "ImportPath": "log/internal", + "Standard": true +} { "ImportPath": "log", "Standard": true, @@ -1450,9 +1545,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1467,6 +1564,7 @@ "internal/unsafeheader", "io", "io/fs", + "log/internal", "math", "math/bits", "os", @@ -1495,8 +1593,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1523,8 +1623,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -1537,43 +1639,50 @@ "unsafe" ] } +{ + "ImportPath": "internal/bisect", + "Standard": true, + "Deps": [ + "internal/abi", + "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/goarch", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/race", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "sync", + "sync/atomic", + "unsafe" + ] +} { "ImportPath": "internal/godebug", "Standard": true, "Deps": [ - "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", - "internal/itoa", - "internal/oserror", - "internal/poll", "internal/race", - "internal/reflectlite", - "internal/safefilepath", - "internal/syscall/execenv", - "internal/syscall/unix", - "internal/testlog", - "internal/unsafeheader", - "io", - "io/fs", - "math/bits", - "os", - "path", "runtime", "runtime/internal/atomic", "runtime/internal/math", "runtime/internal/sys", "runtime/internal/syscall", - "sort", "sync", "sync/atomic", - "syscall", - "time", - "unicode/utf8", "unsafe" ] } @@ -1587,8 +1696,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -1606,40 +1717,24 @@ "ImportPath": "internal/intern", "Standard": true, "Deps": [ - "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", - "internal/itoa", - "internal/oserror", - "internal/poll", "internal/race", - "internal/reflectlite", - "internal/safefilepath", - "internal/syscall/execenv", - "internal/syscall/unix", - "internal/testlog", - "internal/unsafeheader", - "io", - "io/fs", - "math/bits", - "os", - "path", "runtime", "runtime/internal/atomic", "runtime/internal/math", "runtime/internal/sys", "runtime/internal/syscall", - "sort", "sync", "sync/atomic", - "syscall", - "time", - "unicode/utf8", "unsafe" ] } @@ -1649,40 +1744,30 @@ "Deps": [ "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", "internal/itoa", - "internal/oserror", - "internal/poll", "internal/race", "internal/reflectlite", - "internal/safefilepath", - "internal/syscall/execenv", - "internal/syscall/unix", - "internal/testlog", "internal/unsafeheader", - "io", - "io/fs", "math", "math/bits", - "os", - "path", "runtime", "runtime/internal/atomic", "runtime/internal/math", "runtime/internal/sys", "runtime/internal/syscall", - "sort", "strconv", "sync", "sync/atomic", - "syscall", - "time", "unicode/utf8", "unsafe" ] @@ -1693,8 +1778,10 @@ "Deps": [ "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -1715,10 +1802,13 @@ "context", "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -1766,11 +1856,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -1789,6 +1882,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "net", @@ -1822,8 +1916,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1870,11 +1966,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -1893,6 +1992,7 @@ "io", "io/fs", "log", + "log/internal", "log/syslog", "math", "math/bits", @@ -1935,9 +2035,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -1990,9 +2092,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2051,9 +2155,11 @@ "gopkg.in/yaml.v2", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2101,9 +2207,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2149,9 +2257,11 @@ "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2200,9 +2310,11 @@ "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2247,19 +2359,24 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", "internal/reflectlite", "internal/unsafeheader", "io", + "math", + "math/bits", "runtime", "runtime/internal/atomic", "runtime/internal/math", "runtime/internal/sys", "runtime/internal/syscall", + "strconv", "strings", "sync", "sync/atomic", @@ -2277,9 +2394,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2324,8 +2443,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2376,9 +2497,11 @@ "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2431,9 +2554,11 @@ "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2479,14 +2604,17 @@ "errors", "fmt", "go/ast", + "go/build/constraint", "go/internal/typeparams", "go/scanner", "go/token", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2532,9 +2660,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2580,10 +2710,13 @@ "context", "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2628,10 +2761,13 @@ "context", "errors", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2673,6 +2809,10 @@ "ImportPath": "internal/goversion", "Standard": true } +{ + "ImportPath": "internal/platform", + "Standard": true +} { "ImportPath": "go/build", "Standard": true, @@ -2691,12 +2831,15 @@ "go/scanner", "go/token", "internal/abi", + "internal/bisect", "internal/buildcfg", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/goroot", @@ -2704,6 +2847,7 @@ "internal/itoa", "internal/lazyregexp", "internal/oserror", + "internal/platform", "internal/poll", "internal/race", "internal/reflectlite", @@ -2754,11 +2898,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2804,8 +2951,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2847,9 +2996,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2894,8 +3045,10 @@ "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -2926,9 +3079,11 @@ "hash/crc32", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -2976,8 +3131,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -2999,9 +3156,13 @@ "Standard": true, "Deps": [ "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -3026,10 +3187,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3074,20 +3239,24 @@ "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3130,19 +3299,22 @@ "ImportPath": "crypto/aes", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3170,15 +3342,54 @@ "ImportPath": "crypto/des", "Standard": true, "Deps": [ + "bytes", "crypto/cipher", - "crypto/internal/subtle", + "crypto/internal/alias", + "crypto/subtle", + "encoding/binary", + "errors", + "internal/abi", + "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/goarch", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/itoa", + "internal/race", + "internal/reflectlite", + "internal/unsafeheader", + "io", + "math", + "math/bits", + "reflect", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "strconv", + "sync", + "sync/atomic", + "unicode", + "unicode/utf8", + "unsafe" + ] +} +{ + "ImportPath": "crypto/internal/edwards25519/field", + "Standard": true, + "Deps": [ "crypto/subtle", "encoding/binary", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3210,8 +3421,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -3232,8 +3445,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3270,8 +3485,64 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/goarch", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/itoa", + "internal/oserror", + "internal/race", + "internal/reflectlite", + "internal/unsafeheader", + "io", + "io/fs", + "math", + "math/bits", + "path", + "reflect", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "sort", + "strconv", + "sync", + "sync/atomic", + "syscall", + "time", + "unicode", + "unicode/utf8", + "unsafe" + ] +} +{ + "ImportPath": "crypto/ecdh", + "Standard": true, + "Deps": [ + "bytes", + "crypto", + "crypto/cipher", + "crypto/internal/alias", + "crypto/internal/boring", + "crypto/internal/boring/sig", + "crypto/internal/edwards25519/field", + "crypto/internal/nistec", + "crypto/internal/nistec/fiat", + "crypto/internal/randutil", + "crypto/subtle", + "embed", + "encoding/binary", + "errors", + "hash", + "internal/abi", + "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3314,10 +3585,69 @@ "errors", "fmt", "internal/abi", + "internal/bisect", + "internal/bytealg", + "internal/coverage/rtcov", + "internal/cpu", + "internal/fmtsort", + "internal/goarch", + "internal/godebug", + "internal/godebugs", + "internal/goexperiment", + "internal/goos", + "internal/itoa", + "internal/oserror", + "internal/poll", + "internal/race", + "internal/reflectlite", + "internal/safefilepath", + "internal/syscall/execenv", + "internal/syscall/unix", + "internal/testlog", + "internal/unsafeheader", + "io", + "io/fs", + "math", + "math/big", + "math/bits", + "math/rand", + "os", + "path", + "reflect", + "runtime", + "runtime/internal/atomic", + "runtime/internal/math", + "runtime/internal/sys", + "runtime/internal/syscall", + "sort", + "strconv", + "strings", + "sync", + "sync/atomic", + "syscall", + "time", + "unicode", + "unicode/utf8", + "unsafe" + ] +} +{ + "ImportPath": "crypto/internal/bigmod", + "Standard": true, + "Deps": [ + "bytes", + "encoding/binary", + "errors", + "fmt", + "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3363,19 +3693,23 @@ "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3418,19 +3752,22 @@ "ImportPath": "crypto/sha512", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3463,10 +3800,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3520,10 +3861,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3572,14 +3917,17 @@ "crypto", "crypto/aes", "crypto/cipher", + "crypto/ecdh", "crypto/elliptic", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", + "crypto/internal/edwards25519/field", "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/sha512", "crypto/subtle", "embed", @@ -3589,10 +3937,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3634,40 +3986,6 @@ "vendor/golang.org/x/crypto/cryptobyte/asn1" ] } -{ - "ImportPath": "crypto/internal/edwards25519/field", - "Standard": true, - "Deps": [ - "crypto/subtle", - "encoding/binary", - "errors", - "internal/abi", - "internal/bytealg", - "internal/cpu", - "internal/goarch", - "internal/goexperiment", - "internal/goos", - "internal/itoa", - "internal/race", - "internal/reflectlite", - "internal/unsafeheader", - "io", - "math", - "math/bits", - "reflect", - "runtime", - "runtime/internal/atomic", - "runtime/internal/math", - "runtime/internal/sys", - "runtime/internal/syscall", - "strconv", - "sync", - "sync/atomic", - "unicode", - "unicode/utf8", - "unsafe" - ] -} { "ImportPath": "crypto/internal/edwards25519", "Standard": true, @@ -3678,8 +3996,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3710,12 +4030,12 @@ "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", "crypto/internal/edwards25519", "crypto/internal/edwards25519/field", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/rand", "crypto/sha512", "crypto/subtle", @@ -3724,10 +4044,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3770,19 +4094,22 @@ "ImportPath": "crypto/hmac", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3816,8 +4143,10 @@ "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3845,12 +4174,14 @@ "ImportPath": "crypto/rc4", "Standard": true, "Deps": [ - "crypto/internal/subtle", + "crypto/internal/alias", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/reflectlite", @@ -3874,11 +4205,12 @@ "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/rand", "crypto/subtle", "encoding/binary", @@ -3886,10 +4218,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3932,19 +4268,22 @@ "ImportPath": "crypto/sha1", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -3978,10 +4317,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4031,10 +4374,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4084,8 +4431,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4119,9 +4468,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4169,9 +4520,12 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -4180,7 +4534,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rsa", @@ -4199,11 +4552,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -4255,7 +4611,7 @@ ] } { - "ImportPath": "vendor/golang.org/x/crypto/internal/subtle", + "ImportPath": "vendor/golang.org/x/crypto/internal/alias", "Standard": true, "Deps": [ "unsafe" @@ -4265,15 +4621,18 @@ "ImportPath": "vendor/golang.org/x/crypto/chacha20", "Standard": true, "Deps": [ + "bytes", "crypto/cipher", - "crypto/internal/subtle", + "crypto/internal/alias", "crypto/subtle", "encoding/binary", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4295,7 +4654,7 @@ "unicode", "unicode/utf8", "unsafe", - "vendor/golang.org/x/crypto/internal/subtle" + "vendor/golang.org/x/crypto/internal/alias" ] } { @@ -4307,8 +4666,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4339,8 +4700,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4356,6 +4719,7 @@ "io", "io/fs", "io/ioutil", + "math", "math/bits", "os", "path", @@ -4365,6 +4729,7 @@ "runtime/internal/sys", "runtime/internal/syscall", "sort", + "strconv", "strings", "sync", "sync/atomic", @@ -4379,15 +4744,18 @@ "ImportPath": "vendor/golang.org/x/crypto/chacha20poly1305", "Standard": true, "Deps": [ + "bytes", "crypto/cipher", - "crypto/internal/subtle", + "crypto/internal/alias", "crypto/subtle", "encoding/binary", "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4424,112 +4792,32 @@ "unicode/utf8", "unsafe", "vendor/golang.org/x/crypto/chacha20", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/sys/cpu" ] } -{ - "ImportPath": "vendor/golang.org/x/crypto/curve25519/internal/field", - "Standard": true, - "Deps": [ - "crypto/subtle", - "encoding/binary", - "errors", - "internal/abi", - "internal/bytealg", - "internal/cpu", - "internal/goarch", - "internal/goexperiment", - "internal/goos", - "internal/itoa", - "internal/race", - "internal/reflectlite", - "internal/unsafeheader", - "io", - "math", - "math/bits", - "reflect", - "runtime", - "runtime/internal/atomic", - "runtime/internal/math", - "runtime/internal/sys", - "runtime/internal/syscall", - "strconv", - "sync", - "sync/atomic", - "unicode", - "unicode/utf8", - "unsafe" - ] -} -{ - "ImportPath": "vendor/golang.org/x/crypto/curve25519", - "Standard": true, - "Deps": [ - "crypto/subtle", - "encoding/binary", - "errors", - "fmt", - "internal/abi", - "internal/bytealg", - "internal/cpu", - "internal/fmtsort", - "internal/goarch", - "internal/goexperiment", - "internal/goos", - "internal/itoa", - "internal/oserror", - "internal/poll", - "internal/race", - "internal/reflectlite", - "internal/safefilepath", - "internal/syscall/execenv", - "internal/syscall/unix", - "internal/testlog", - "internal/unsafeheader", - "io", - "io/fs", - "math", - "math/bits", - "os", - "path", - "reflect", - "runtime", - "runtime/internal/atomic", - "runtime/internal/math", - "runtime/internal/sys", - "runtime/internal/syscall", - "sort", - "strconv", - "sync", - "sync/atomic", - "syscall", - "time", - "unicode", - "unicode/utf8", - "unsafe", - "vendor/golang.org/x/crypto/curve25519/internal/field" - ] -} { "ImportPath": "vendor/golang.org/x/crypto/hkdf", "Standard": true, "Deps": [ + "bytes", "crypto", "crypto/cipher", "crypto/hmac", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", - "crypto/internal/subtle", "crypto/subtle", "encoding/binary", "errors", "hash", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4565,10 +4853,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -4577,7 +4868,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -4598,11 +4888,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -4653,11 +4946,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/sys/cpu" ] @@ -4670,8 +4961,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -4700,9 +4993,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4718,6 +5013,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "os", @@ -4749,9 +5045,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4767,6 +5065,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "os", @@ -4800,9 +5099,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4850,9 +5151,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -4868,6 +5171,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "os", @@ -4904,11 +5208,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -4964,11 +5271,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -4987,6 +5297,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "net", @@ -5030,11 +5341,14 @@ "errors", "fmt", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5053,6 +5367,7 @@ "io", "io/fs", "log", + "log/internal", "math", "math/bits", "net", @@ -5094,9 +5409,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -5144,9 +5461,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -5193,9 +5512,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -5241,10 +5562,10 @@ "context", "crypto", "crypto/cipher", + "crypto/internal/alias", "crypto/internal/boring", "crypto/internal/boring/sig", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/rand", "crypto/subtle", "encoding/base64", @@ -5253,11 +5574,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5320,10 +5644,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -5332,7 +5659,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -5354,11 +5680,14 @@ "fmt", "hash", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5410,11 +5739,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/sys/cpu" ] @@ -5429,9 +5756,11 @@ "fmt", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/itoa", @@ -5475,8 +5804,10 @@ "errors", "internal/abi", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/goarch", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/race", @@ -5511,10 +5842,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -5523,7 +5857,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -5546,11 +5879,14 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5570,6 +5906,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -5609,11 +5946,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -5646,10 +5981,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -5658,7 +5996,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -5685,11 +6022,14 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/intern", @@ -5709,6 +6049,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "math", "math/big", "math/bits", @@ -5752,11 +6093,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -5791,10 +6130,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -5803,7 +6145,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -5845,12 +6186,15 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/buildcfg", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/goroot", @@ -5860,6 +6204,7 @@ "internal/lazyregexp", "internal/nettrace", "internal/oserror", + "internal/platform", "internal/poll", "internal/race", "internal/reflectlite", @@ -5873,6 +6218,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "log/syslog", "math", "math/big", @@ -5917,11 +6263,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", @@ -5955,10 +6299,13 @@ "crypto/cipher", "crypto/des", "crypto/dsa", + "crypto/ecdh", "crypto/ecdsa", "crypto/ed25519", "crypto/elliptic", "crypto/hmac", + "crypto/internal/alias", + "crypto/internal/bigmod", "crypto/internal/boring", "crypto/internal/boring/bbig", "crypto/internal/boring/sig", @@ -5967,7 +6314,6 @@ "crypto/internal/nistec", "crypto/internal/nistec/fiat", "crypto/internal/randutil", - "crypto/internal/subtle", "crypto/md5", "crypto/rand", "crypto/rc4", @@ -6014,12 +6360,15 @@ "hash", "hash/crc32", "internal/abi", + "internal/bisect", "internal/buildcfg", "internal/bytealg", + "internal/coverage/rtcov", "internal/cpu", "internal/fmtsort", "internal/goarch", "internal/godebug", + "internal/godebugs", "internal/goexperiment", "internal/goos", "internal/goroot", @@ -6029,6 +6378,7 @@ "internal/lazyregexp", "internal/nettrace", "internal/oserror", + "internal/platform", "internal/poll", "internal/race", "internal/reflectlite", @@ -6042,6 +6392,7 @@ "io/fs", "io/ioutil", "log", + "log/internal", "log/syslog", "math", "math/big", @@ -6086,11 +6437,9 @@ "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/cryptobyte", "vendor/golang.org/x/crypto/cryptobyte/asn1", - "vendor/golang.org/x/crypto/curve25519", - "vendor/golang.org/x/crypto/curve25519/internal/field", "vendor/golang.org/x/crypto/hkdf", + "vendor/golang.org/x/crypto/internal/alias", "vendor/golang.org/x/crypto/internal/poly1305", - "vendor/golang.org/x/crypto/internal/subtle", "vendor/golang.org/x/net/dns/dnsmessage", "vendor/golang.org/x/net/http/httpguts", "vendor/golang.org/x/net/http/httpproxy", From 7f70467fce8eaea77a07f6ef45afead920abe8a8 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Fri, 2 Feb 2024 17:10:54 +0100 Subject: [PATCH 21/23] package_managers: gomod: Fix docstring typo 'returs' -> 'returns' Signed-off-by: Erik Skultety --- cachi2/core/package_managers/gomod.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cachi2/core/package_managers/gomod.py b/cachi2/core/package_managers/gomod.py index 7f98b677b..f3cbbfee0 100644 --- a/cachi2/core/package_managers/gomod.py +++ b/cachi2/core/package_managers/gomod.py @@ -249,7 +249,7 @@ def __call__(self, cmd: list[str], params: Optional[dict] = None, retry: bool = :param cmd: Go CLI options :param params: additional subprocess arguments, e.g. 'env' :param retry: whether the command should be retried on failure (e.g. network actions) - :returs: Go command's output + :returns: Go command's output """ if params is None: params = {} From 9351f07967e4e3e8599a35d327c9edf417ff9c63 Mon Sep 17 00:00:00 2001 From: Erik Skultety Date: Fri, 2 Feb 2024 17:11:33 +0100 Subject: [PATCH 22/23] README: Bump the supported Go version to 1.21 and document differences Signed-off-by: Erik Skultety --- README.md | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index d0e3143fd..222e29dd1 100644 --- a/README.md +++ b/README.md @@ -308,7 +308,7 @@ original Cachito.* -Current version: 1.20 [^go-version] [^go-compat] +Current version: 1.21 [^go-version] [^go-compat] The gomod package manager works by parsing the [go.mod](https://go.dev/ref/mod#go-mod-file) file present in the source repository to determine which dependencies to download. Cachi2 does not parse this file on its own - rather, we rely on @@ -333,6 +333,17 @@ See [docs/gomod.md](docs/gomod.md) for more details. the two versions. For example, dependency resolution did change in [go 1.18][go118-changelog] but not in [go 1.19][go119-changelog]. +#### Go 1.21+ *(since cachi2-v0.5.0)* + Starting with [Go 1.21][go121-changelog], Go changed the meaning of the `go 1.X` directive in + that it now specifies the [minimum required version](https://go.dev/ref/mod#go-mod-file-go) of Go + rather than a suggested version as it originally did. The format of the version string in the + `go` directive now also includes the micro release and if you don't include the micro release in + your `go.mod` file yourself (i.e. you only specify the language release) Go will try to correct + it automatically inside the file. Last but not least, Go 1.21 also introduced a new keyword + [`toolchain`](https://go.dev/ref/mod#go-mod-file-toolchain) to the `go.mod` file. What this all + means in practice for end users is that you may not be able to process your `go.mod` file with an older version + of Go (and hence older cachi2) as you could in the past for various reasons. + ### pip @@ -392,4 +403,5 @@ still in early development phase. [go117-changelog]: https://tip.golang.org/doc/go1.17#go-command [go118-changelog]: https://tip.golang.org/doc/go1.18#go-command [go119-changelog]: https://tip.golang.org/doc/go1.19#go-command +[go121-changelog]: https://tip.golang.org/doc/go1.21 [ocp-cachi2-pipelines]: https://console-openshift-console.apps.stone-prd-rh01.pg1f.p1.openshiftapps.com/pipelines/ns/tekton-ci/pipeline-runs?name=cachi2 From 6129c17ed89b3d8398bee9cdf0b67e1266a8a30f Mon Sep 17 00:00:00 2001 From: Bruno Pimentel Date: Wed, 10 Jan 2024 17:35:57 -0300 Subject: [PATCH 23/23] Support new tool metadata format in the merge syft sbom script CycloneDX 1.5 changes the way to define tools in the metadata section, and marks the 1.4 way as deprecated. Syft has adopted the newer format starting from version 0.99.0. This makes the 'merge_syft_sbom.py' script to fail in case a newer Syft SBOM is used. This patch updates the script so both formats can be handled. It assumes the Cachi2 SBOM is in the 1.4 format. Signed-off-by: Bruno Pimentel --- tests/unit/data/sboms/merged.bom.json | 31 ++++--- tests/unit/data/sboms/syft.bom.json | 22 +++-- tests/unit/test_merge_syft_sbom.py | 116 ++++++++++++++++++++++++++ utils/merge_syft_sbom.py | 38 ++++++++- 4 files changed, 182 insertions(+), 25 deletions(-) diff --git a/tests/unit/data/sboms/merged.bom.json b/tests/unit/data/sboms/merged.bom.json index dffcfc935..dc876ce57 100644 --- a/tests/unit/data/sboms/merged.bom.json +++ b/tests/unit/data/sboms/merged.bom.json @@ -1,21 +1,26 @@ { + "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json", "bomFormat": "CycloneDX", - "specVersion": "1.4", - "serialNumber": "urn:uuid:43840228-3fae-4d88-95aa-96512d2510dd", + "specVersion": "1.5", + "serialNumber": "urn:uuid:4370d1ba-7643-4579-8313-bc715da2fa90", "version": 1, "metadata": { "timestamp": "2023-05-03T18:19:41Z", - "tools": [ - { - "vendor": "anchore", - "name": "syft", - "version": "0.47.0" - }, - { - "vendor": "red hat", - "name": "cachi2" - } - ], + "tools": { + "components": [ + { + "type": "application", + "author": "anchore", + "name": "syft", + "version": "0.100.0" + }, + { + "type": "application", + "author": "red hat", + "name": "cachi2" + } + ] + }, "component": { "bom-ref": "6b8edfe5f2756e0", "type": "file", diff --git a/tests/unit/data/sboms/syft.bom.json b/tests/unit/data/sboms/syft.bom.json index 8b251d74c..6bf35bc24 100644 --- a/tests/unit/data/sboms/syft.bom.json +++ b/tests/unit/data/sboms/syft.bom.json @@ -1,17 +1,21 @@ { + "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json", "bomFormat": "CycloneDX", - "specVersion": "1.4", - "serialNumber": "urn:uuid:43840228-3fae-4d88-95aa-96512d2510dd", + "specVersion": "1.5", + "serialNumber": "urn:uuid:4370d1ba-7643-4579-8313-bc715da2fa90", "version": 1, "metadata": { "timestamp": "2023-05-03T18:19:41Z", - "tools": [ - { - "vendor": "anchore", - "name": "syft", - "version": "0.47.0" - } - ], + "tools": { + "components": [ + { + "type": "application", + "author": "anchore", + "name": "syft", + "version": "0.100.0" + } + ] + }, "component": { "bom-ref": "6b8edfe5f2756e0", "type": "file", diff --git a/tests/unit/test_merge_syft_sbom.py b/tests/unit/test_merge_syft_sbom.py index 119d61a48..6329be85f 100644 --- a/tests/unit/test_merge_syft_sbom.py +++ b/tests/unit/test_merge_syft_sbom.py @@ -1,8 +1,34 @@ import json from pathlib import Path +from typing import Any + +import pytest from utils.merge_syft_sbom import merge_sboms +TOOLS_METADATA = { + "syft-cyclonedx-1.4": { + "name": "syft", + "vendor": "anchore", + "version": "0.47.0", + }, + "syft-cyclonedx-1.5": { + "type": "application", + "author": "anchore", + "name": "syft", + "version": "0.100.0", + }, + "cachi2-cyclonedx-1.4": { + "name": "cachi2", + "vendor": "red hat", + }, + "cachi2-cyclonedx-1.5": { + "type": "application", + "author": "red hat", + "name": "cachi2", + }, +} + def test_merge_sboms(data_dir: Path) -> None: result = merge_sboms(f"{data_dir}/sboms/cachi2.bom.json", f"{data_dir}/sboms/syft.bom.json") @@ -11,3 +37,93 @@ def test_merge_sboms(data_dir: Path) -> None: expected_sbom = json.load(file) assert json.loads(result) == expected_sbom + + +@pytest.mark.parametrize( + "syft_tools_metadata, expected_result", + [ + ( + [TOOLS_METADATA["syft-cyclonedx-1.4"]], + [ + TOOLS_METADATA["syft-cyclonedx-1.4"], + TOOLS_METADATA["cachi2-cyclonedx-1.4"], + ], + ), + ( + { + "components": [TOOLS_METADATA["syft-cyclonedx-1.5"]], + }, + { + "components": [ + TOOLS_METADATA["syft-cyclonedx-1.5"], + TOOLS_METADATA["cachi2-cyclonedx-1.5"], + ], + }, + ), + ], +) +def test_merging_tools_metadata( + syft_tools_metadata: str, expected_result: Any, tmpdir: Path +) -> None: + syft_sbom = { + "bomFormat": "CycloneDX", + "specVersion": "1.5", + "metadata": { + "tools": syft_tools_metadata, + }, + "components": [], + } + + cachi2_sbom = { + "bomFormat": "CycloneDX", + "specVersion": "1.4", + "metadata": { + "tools": [TOOLS_METADATA["cachi2-cyclonedx-1.4"]], + }, + "components": [], + } + + syft_sbom_path = f"{tmpdir}/syft.bom.json" + cachi2_sbom_path = f"{tmpdir}/cachi2.bom.json" + + with open(syft_sbom_path, "w") as file: + json.dump(syft_sbom, file) + + with open(cachi2_sbom_path, "w") as file: + json.dump(cachi2_sbom, file) + + result = merge_sboms(cachi2_sbom_path, syft_sbom_path) + + assert json.loads(result)["metadata"]["tools"] == expected_result + + +def test_invalid_tools_format(tmpdir: Path) -> None: + syft_sbom = { + "bomFormat": "CycloneDX", + "specVersion": "1.5", + "metadata": { + "tools": "invalid", + }, + "components": [], + } + + cachi2_sbom = { + "bomFormat": "CycloneDX", + "specVersion": "1.4", + "metadata": { + "tools": [TOOLS_METADATA["cachi2-cyclonedx-1.4"]], + }, + "components": [], + } + + syft_sbom_path = f"{tmpdir}/syft.bom.json" + cachi2_sbom_path = f"{tmpdir}/cachi2.bom.json" + + with open(syft_sbom_path, "w") as file: + json.dump(syft_sbom, file) + + with open(cachi2_sbom_path, "w") as file: + json.dump(cachi2_sbom, file) + + with pytest.raises(RuntimeError): + merge_sboms(cachi2_sbom_path, syft_sbom_path) diff --git a/utils/merge_syft_sbom.py b/utils/merge_syft_sbom.py index c2c4f5096..ad4edbe8d 100755 --- a/utils/merge_syft_sbom.py +++ b/utils/merge_syft_sbom.py @@ -118,6 +118,40 @@ def component_is_duplicated(component: dict[str, Any]) -> bool: return component_is_duplicated +def _merge_tools_metadata(syft_sbom: dict[Any, Any], cachi2_sbom: dict[Any, Any]) -> None: + """Merge the content of tools in the metadata section of the SBOM. + + With CycloneDX 1.5, a new format for specifying tools was introduced, and the format from 1.4 + was marked as deprecated. + + This function aims to support both formats in the Syft SBOM. We're assuming the Cachi2 SBOM + was generated with the same version as this script, and it will be in the older format. + """ + syft_tools = syft_sbom["metadata"]["tools"] + cachi2_tools = cachi2_sbom["metadata"]["tools"] + + if isinstance(syft_tools, dict): + components = [] + + for t in cachi2_tools: + components.append( + { + "author": t["vendor"], + "name": t["name"], + "type": "application", + } + ) + + syft_tools["components"].extend(components) + elif isinstance(syft_tools, list): + syft_tools.extend(cachi2_tools) + else: + raise RuntimeError( + "The .metadata.tools JSON key is in an unexpected format. " + f"Expected dict or list, got {type(syft_tools)}." + ) + + def merge_sboms(cachi2_sbom_path: str, syft_sbom_path: str) -> str: """Merge Cachi2 components into the Syft SBOM while removing duplicates.""" with open(cachi2_sbom_path) as file: @@ -134,9 +168,7 @@ def merge_sboms(cachi2_sbom_path: str, syft_sbom_path: str) -> str: syft_sbom["components"] = filtered_syft_components + cachi2_sbom["components"] - syft_sbom.get("metadata", {}).get("tools", []).extend( - cachi2_sbom.get("metadata", {}).get("tools", []) - ) + _merge_tools_metadata(syft_sbom, cachi2_sbom) return json.dumps(syft_sbom, indent=2)