github.com/go-asm/go@v1.21.1-0.20240213172139-40c5ead50c48/cmd/go/modfetch/toolchain.go

// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package modfetch

import (
	"context"
	"fmt"
	"io"
	"sort"
	"strings"

	"github.com/go-asm/go/cmd/go/gover"
	"github.com/go-asm/go/cmd/go/modfetch/codehost"
)

// A toolchainRepo is a synthesized repository reporting Go toolchain versions.
// It has path "go" or "toolchain". The "go" repo reports versions like "1.2".
// The "toolchain" repo reports versions like "go1.2".
//
// Note that the repo ONLY reports versions. It does not actually support
// downloading of the actual toolchains. Instead, that is done using
// the regular repo code with "golang.org/toolchain".
// The naming conflict is unfortunate: "golang.org/toolchain"
// should perhaps have been "go.dev/dl", but it's too late.
//
// For clarity, this file refers to golang.org/toolchain as the "DL" repo,
// the one you can actually download.
type toolchainRepo struct {
	path string // either "go" or "toolchain"
	repo Repo   // underlying DL repo
}

func (r *toolchainRepo) ModulePath() string {
	return r.path
}

func (r *toolchainRepo) Versions(ctx context.Context, prefix string) (*Versions, error) {
	// Read DL repo list and convert to "go" or "toolchain" version list.
	versions, err := r.repo.Versions(ctx, "")
	if err != nil {
		return nil, err
	}
	versions.Origin = nil
	var list []string
	have := make(map[string]bool)
	goPrefix := ""
	if r.path == "toolchain" {
		goPrefix = "go"
	}
	for _, v := range versions.List {
		v, ok := dlToGo(v)
		if !ok {
			continue
		}
		if !have[v] {
			have[v] = true
			list = append(list, goPrefix+v)
		}
	}

	// Always include our own version.
	// This means that the development branch of Go 1.21 (say) will allow 'go get go@1.21'
	// even though there are no Go 1.21 releases yet.
	// Once there is a release, 1.21 will be treated as a query matching the latest available release.
	// Before then, 1.21 will be treated as a query that resolves to this entry we are adding (1.21).
	if v := gover.Local(); !have[v] {
		list = append(list, goPrefix+v)
	}

	if r.path == "go" {
		sort.Slice(list, func(i, j int) bool {
			return gover.Compare(list[i], list[j]) < 0
		})
	} else {
		sort.Slice(list, func(i, j int) bool {
			return gover.Compare(gover.FromToolchain(list[i]), gover.FromToolchain(list[j])) < 0
		})
	}
	versions.List = list
	return versions, nil
}

func (r *toolchainRepo) Stat(ctx context.Context, rev string) (*RevInfo, error) {
	// Convert rev to DL version and stat that to make sure it exists.
	// In theory the go@ versions should be like 1.21.0
	// and the toolchain@ versions should be like go1.21.0
	// but people will type the wrong one, and so we accept
	// both and silently correct it to the standard form.
	prefix := ""
	v := rev
	v = strings.TrimPrefix(v, "go")
	if r.path == "toolchain" {
		prefix = "go"
	}

	if !gover.IsValid(v) {
		return nil, fmt.Errorf("invalid %s version %s", r.path, rev)
	}

	// If we're asking about "go" (not "toolchain"), pretend to have
	// all earlier Go versions available without network access:
	// we will provide those ourselves, at least in GOTOOLCHAIN=auto mode.
	if r.path == "go" && gover.Compare(v, gover.Local()) <= 0 {
		return &RevInfo{Version: prefix + v}, nil
	}

	// Similarly, if we're asking about *exactly* the current toolchain,
	// we don't need to access the network to know that it exists.
	if r.path == "toolchain" && v == gover.Local() {
		return &RevInfo{Version: prefix + v}, nil
	}

	if gover.IsLang(v) {
		// We can only use a language (development) version if the current toolchain
		// implements that version, and the two checks above have ruled that out.
		return nil, fmt.Errorf("go language version %s is not a toolchain version", rev)
	}

	// Check that the underlying toolchain exists.
	// We always ask about linux-amd64 because that one
	// has always existed and is likely to always exist in the future.
	// This avoids different behavior validating go versions on different
	// architectures. The eventual download uses the right GOOS-GOARCH.
	info, err := r.repo.Stat(ctx, goToDL(v, "linux", "amd64"))
	if err != nil {
		return nil, err
	}

	// Return the info using the canonicalized rev
	// (toolchain 1.2 => toolchain go1.2).
	return &RevInfo{Version: prefix + v, Time: info.Time}, nil
}

func (r *toolchainRepo) Latest(ctx context.Context) (*RevInfo, error) {
	versions, err := r.Versions(ctx, "")
	if err != nil {
		return nil, err
	}
	var max string
	for _, v := range versions.List {
		if max == "" || gover.ModCompare(r.path, v, max) > 0 {
			max = v
		}
	}
	return r.Stat(ctx, max)
}

func (r *toolchainRepo) GoMod(ctx context.Context, version string) (data []byte, err error) {
	return []byte("module " + r.path + "\n"), nil
}

func (r *toolchainRepo) Zip(ctx context.Context, dst io.Writer, version string) error {
	return fmt.Errorf("invalid use of toolchainRepo: Zip")
}

func (r *toolchainRepo) CheckReuse(ctx context.Context, old *codehost.Origin) error {
	return fmt.Errorf("invalid use of toolchainRepo: CheckReuse")
}

// goToDL converts a Go version like "1.2" to a DL module version like "v0.0.1-go1.2.linux-amd64".
func goToDL(v, goos, goarch string) string {
	return "v0.0.1-go" + v + ".linux-amd64"
}

// dlToGo converts a DL module version like "v0.0.1-go1.2.linux-amd64" to a Go version like "1.2".
func dlToGo(v string) (string, bool) {
	// v0.0.1-go1.19.7.windows-amd64
	// cut v0.0.1-
	_, v, ok := strings.Cut(v, "-")
	if !ok {
		return "", false
	}
	// cut .windows-amd64
	i := strings.LastIndex(v, ".")
	if i < 0 || !strings.Contains(v[i+1:], "-") {
		return "", false
	}
	return strings.TrimPrefix(v[:i], "go"), true
}