// like the use of "net/http" in vcs.go.

package web

import (
	"errors"
	urlpkg "net/url"
)

func get(security SecurityMode, url *urlpkg.URL) (*Response, error) {
	return nil, errors.New("no http in bootstrap go command")
}

func openBrowser(url string) bool { return false }

		res.Body = hookCloser{
			ReadCloser: body,
			afterClose: release,
		}
		return res, err
	}

	var (
		fetched *urlpkg.URL
		res     *http.Response
		err     error
	)
	if url.Scheme == "" || url.Scheme == "https" {
		secure := new(urlpkg.URL)
		*secure = *url
		secure.Scheme = "https"

		res, err = fetch(secure)
		if err == nil {
			fetched = secure
		} else {

		return "", err
	}
	out := strings.TrimSpace(string(outb))

	var repoURL *urlpkg.URL
	if m := scpSyntaxRe.FindStringSubmatch(out); m != nil {
		// Match SCP-like syntax and convert it to a URL.
		// Eg, "******@****.***:user/repo" becomes
		// "ssh://******@****.***/user/repo".
		repoURL = &urlpkg.URL{
			Scheme: "ssh",
			User:   urlpkg.User(m[1]),
			Host:   m[2],
			Path:   m[3],
		}
	} else {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package bug implements the “go bug” command.
package bug

import (
	"bytes"
	"context"
	"fmt"
	"io"
	urlpkg "net/url"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"runtime"
	"strings"

	"cmd/go/internal/base"
	"cmd/go/internal/cfg"
	"cmd/go/internal/envcmd"
	"cmd/go/internal/web"
	"cmd/go/internal/work"

	"bufio"
	"bytes"
	"context"
	"crypto/tls"
	"encoding/base64"
	"errors"
	"fmt"
	"io"
	"mime"
	"mime/multipart"
	"net/http/httptrace"
	"net/http/internal/ascii"
	"net/textproto"
	"net/url"
	urlpkg "net/url"
	"strconv"
	"strings"
	"sync"
	_ "unsafe" // for linkname

	"golang.org/x/net/http/httpguts"
	"golang.org/x/net/idna"
)

const (
	defaultMaxMemory = 32 << 20 // 32 MB
)

package http

import (
	"bufio"
	"bytes"
	"context"
	"crypto/tls"
	"errors"
	"fmt"
	"internal/godebug"
	"io"
	"log"
	"math/rand"
	"net"
	"net/textproto"
	"net/url"
	urlpkg "net/url"
	"path"
	"runtime"
	"slices"
	"strconv"
	"strings"
	"sync"
	"sync/atomic"
	"time"
	_ "unsafe" // for linkname

	"golang.org/x/net/http/httpguts"
)

	listCmd := testenv.Command(t, goBin, "list", "std", "cmd")
	out, err := listCmd.Output()
	if err != nil {
		t.Fatal(err)
	}
	for _, fullPkg := range strings.Split(string(out), "\n") {
		pkg, found := strings.CutPrefix(fullPkg, "vendor/")
		if !found {
			_, pkg, found = strings.Cut(fullPkg, "/vendor/")
			if !found {
				continue
			}
		}
		if !isAllowed(pkg) {
			t.Errorf(`

	case 'F', 'G':
		var tparams []*types.TypeParam
		if tag == 'G' {
			tparams = r.tparamList()
		}
		sig := r.signature(nil, nil, tparams)
		r.declare(types.NewFunc(pos, r.currPkg, name, sig))

	case 'T', 'U':
		// Types can be recursive. We need to setup a stub
		// declaration before recurring.
		obj := types.NewTypeName(pos, r.currPkg, name, nil)

	scanner := bufio.NewScanner(bytes.NewReader(out))
	curPkg := ""
	canInline := regexp.MustCompile(`: can inline ([^ ]*)`)
	haveInlined := regexp.MustCompile(`: inlining call to ([^ ]*)`)
	cannotInline := regexp.MustCompile(`: cannot inline ([^ ]*): (.*)`)
	for scanner.Scan() {
		line := scanner.Text()
		t.Logf("child: %s", line)
		if strings.HasPrefix(line, "# ") {
			curPkg = line[2:]
			splits := strings.Split(curPkg, " ")

	example.net/pkgremoved v0.1.0 => ./prpkg
	example.net/pkgremoved v0.1.1 => ./prpkg

	example.net/pkgremoved v0.2.0 => ./prmod
	example.net/pkgremoved v0.2.1 => ./prmod

	example.net/pkgremoved v0.3.0 => ./prpkg
	example.net/pkgremoved v0.3.1 => ./prmod

	example.net/pkgremoved v0.4.0 => ./prmod
	example.net/pkgremoved v0.4.1 => ./prpkg
)
-- other/go.mod --
module example.net/other

go 1.16