cxx, err := exec.Command("go", "env", "CXX").CombinedOutput()
	if err != nil {
		t.Fatalf("go env CXX failed: %s", err)
	}
	args, err := quoted.Split(string(cxx))
	if err != nil {
		t.Skipf("could not parse 'go env CXX' output %q: %s", string(cxx), err)
	}
	if len(args) == 0 {
		t.Skip("no C++ compiler")
	}
	testenv.MustHaveExecPath(t, string(args[0]))
}

var (
	swigOnce sync.Once
	haveSwig bool

reserved.
L2::: Use of this source code is governed by a BSD-style
L3::: license that can be found in the LICENSE file.
L4:
L5:@echo off
L6:
L7:setlocal
L8:
L9:if exist make.bat goto ok
L10:echo all.bat must be run from go\src
L11::: cannot exit: would kill parent command interpreter
L12:goto end
L13::ok
L14:
L15:call .\make.bat --no-banner --no-local
L16:if %GOBUILDFAIL%==1 goto end
L17:call .\run.bat --no-rebuild --no-local
L18:if %GOBUILDFAIL%==1 goto end
L19:"%GOTOOLDIR%/dist" banner
...

error message, but this package reserves the right to not force a fault on
freed memory. That means a valid implementation of this package is to just
allocate all memory the way the runtime normally would, and in fact, it
reserves the right to occasionally do so for some Go values.
*/
package arena

import (
	"internal/reflectlite"
	"unsafe"
)

			ok:        true,
			out:       "",
		},

		// Test that a feature required on a subset of ports is implicitly satisfied
		// by the same feature being implemented on all ports. That is, it shouldn't
		// say "pkg syscall (darwin-amd64), type RawSockaddrInet6 struct" is missing.
		// See https://go.dev/issue/4303.
		{
			name: "contexts reconverging after api/next/* update",
			features: []string{
				"A",

  - type: input
    id: package-path
    attributes:
      label: "What is the path of the package that you would like to have removed?"
      description: |
        We can remove packages with a shared path prefix.
        For example, a request for 'github.com/author' would remove all pkg.go.dev pages with that package path prefix.
    validations:
      required: true
  - type: textarea
    id: package-owner

      description: "Is the goal of this change a performance improvement? If so, what quantifiable improvement should we expect? How would we measure it?"
    validations:
      required: false

  - type: textarea
    id: learning-curve
    attributes:
      label: "Would this change make Go easier or harder to learn, and why?"

  - type: textarea
    id: cost-description
    attributes:

)

// This file tests the situation where byte operations are checking
// data very near to a page boundary. We want to make sure those
// operations do not read across the boundary and cause a page
// fault where they shouldn't.

// These tests run only on linux. The code being tested is
// not OS-specific, so it does not need to be tested on all
// operating systems.

// dangerousSlice returns a slice which is immediately

	return t.base
}

func (t *Tokenizer) SetBase(base *src.PosBase) {
	t.base = base
}

func (t *Tokenizer) Line() int {
	return t.line
}

func (t *Tokenizer) Col() int {
	return t.s.Pos().Column
}

func (t *Tokenizer) Next() ScanToken {
	s := t.s
	for {
		t.tok = ScanToken(s.Scan())
		if t.tok != scanner.Comment {
			break
		}
		text := s.TokenText()

func ExampleScanner_Bytes() {
	scanner := bufio.NewScanner(strings.NewReader("gopher"))
	for scanner.Scan() {
		fmt.Println(len(scanner.Bytes()) == 6)
	}
	if err := scanner.Err(); err != nil {
		fmt.Fprintln(os.Stderr, "shouldn't see an error scanning a string")
	}
	// Output:
	// true
}

// Use a Scanner to implement a simple word-count utility by scanning the
// input as a sequence of space-delimited tokens.

// AST expression onto a single line. The lexer normally inserts a
// semicolon at each newline, so we can replace newline with semicolon.
// However, we can't do that in cases where the lexer would not insert
// a semicolon. We only have to worry about cases that can occur in an
// expression passed through gofmt, which means composite literals and
// (due to the printer possibly inserting newlines because of position