[dev.boringcrypto] misc/boring: add new releases to RELEASES file

Change-Id: Idd94c25072d625c158553db2aecb3466c16d395b
Reviewed-on: https://go-review.googlesource.com/c/go/+/461395
Reviewed-by: Heschi Kreinick <heschi@google.com>
TryBot-Bypass: Carlos Amedee <carlos@golang.org>
Reviewed-by: Carlos Amedee <carlos@golang.org>
Auto-Submit: Carlos Amedee <carlos@golang.org>

.github/ISSUE_TEMPLATE/00-bug.md

@@ -0,0 +1,45 @@
+---
+name: Bugs
+about: The go command, standard library, or anything else
+title: "affected/package: "
+---
+
+<!--
+Please answer these questions before submitting your issue. Thanks!
+-->
+
+### What version of Go are you using (`go version`)?
+
+<pre>
+$ go version
+
+</pre>
+
+### Does this issue reproduce with the latest release?
+
+
+
+### What operating system and processor architecture are you using (`go env`)?
+
+<details><summary><code>go env</code> Output</summary><br><pre>
+$ go env
+
+</pre></details>
+
+### What did you do?
+
+<!--
+If possible, provide a recipe for reproducing the error.
+A complete runnable program is good.
+A link on go.dev/play is best.
+-->
+
+
+
+### What did you expect to see?
+
+
+
+### What did you see instead?
+
+

.github/ISSUE_TEMPLATE/00-bug.yml

@@ -1,94 +0,0 @@
-# https://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/configuring-issue-templates-for-your-repository#creating-issue-forms
-# https://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema
-name: Bugs
-description: The go command, standard library, or anything else
-title: "import/path: issue title"
-
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for helping us improve! 🙏 Please answer these questions and provide as much information as possible about your problem.
-
-  - type: input
-    id: go-version
-    attributes:
-      label: Go version
-      description: |
-        What version of Go are you using (`go version`)?
-
-        Note: we only [support](https://go.dev/doc/devel/release#policy) the two most recent major releases.
-      placeholder: ex. go version go1.20.7 darwin/arm64
-    validations:
-      required: true
-
-  - type: textarea
-    id: go-env
-    attributes:
-      label: "Output of `go env` in your module/workspace:"
-      placeholder: |
-        GO111MODULE=""
-        GOARCH="arm64"
-        GOBIN="/Users/gopher/go/bin"
-        GOCACHE="/Users/gopher/go/cache"
-        GOENV="/Users/gopher/Library/Application Support/go/env"
-        GOEXE=""
-        GOEXPERIMENT=""
-        GOFLAGS=""
-        GOHOSTARCH="arm64"
-        GOHOSTOS="darwin"
-        GOINSECURE=""
-        GOMODCACHE="/Users/gopher/go/pkg/mod"
-        GONOPROXY=""
-        GONOSUMDB=""
-        GOOS="darwin"
-        GOPATH="/Users/gopher/go"
-        GOPRIVATE=""
-        GOPROXY="https://proxy.golang.org,direct"
-        GOROOT="/usr/local/go"
-        GOSUMDB="sum.golang.org"
-        GOTMPDIR=""
-        GOTOOLDIR="/usr/local/go/pkg/tool/darwin_arm64"
-        GOVCS=""
-        GOVERSION="go1.20.7"
-        GCCGO="gccgo"
-        AR="ar"
-        CC="clang"
-        CXX="clang++"
-        CGO_ENABLED="1"
-        GOMOD="/dev/null"
-        GOWORK=""
-        CGO_CFLAGS="-O2 -g"
-        CGO_CPPFLAGS=""
-        CGO_CXXFLAGS="-O2 -g"
-        CGO_FFLAGS="-O2 -g"
-        CGO_LDFLAGS="-O2 -g"
-        PKG_CONFIG="pkg-config"
-        GOGCCFLAGS="-fPIC -arch arm64 -pthread -fno-caret-diagnostics -Qunused-arguments -fmessage-length=0 -fdebug-prefix-map=/var/folders/44/nbbyll_10jd0z8rj_qxm43740000gn/T/go-build2331607515=/tmp/go-build -gno-record-gcc-switches -fno-common"
-      render: shell
-    validations:
-      required: true
-
-  - type: textarea
-    id: what-did-you-do
-    attributes:
-      label: "What did you do?"
-      description: "If possible, provide a recipe for reproducing the error. A complete runnable program is good. A link on [go.dev/play](https://go.dev/play) is best."
-    validations:
-      required: true
-
-  - type: textarea
-    id: actual-behavior
-    attributes:
-      label: "What did you see happen?"
-      description: Command invocations and their associated output, functions with their arguments and return results, full stacktraces for panics (upload a file if it is very long), etc. Prefer copying text output over using screenshots.
-    validations:
-      required: true
-
-  - type: textarea
-    id: expected-behavior
-    attributes:
-      label: "What did you expect to see?"
-      description: Why is the current output incorrect, and any additional context we may need to understand the issue.
-    validations:
-      required: true

.github/ISSUE_TEMPLATE/01-pkgsite.md

@@ -0,0 +1,47 @@
+---
+name: Pkg.go.dev bugs or feature requests
+about: Issues or feature requests for the documentation site
+title: "x/pkgsite: "
+labels: pkgsite
+---
+
+<!--
+Please answer these questions before submitting your issue. Thanks!
+-->
+
+### What is the URL of the page with the issue?
+
+
+
+### What is your user agent?
+
+<!--
+You can find your user agent here:
+https://www.google.com/search?q=what+is+my+user+agent
+-->
+
+
+
+### Screenshot
+
+<!--
+Please paste a screenshot of the page.
+-->
+
+
+
+### What did you do?
+
+<!--
+If possible, provide a recipe for reproducing the error.
+-->
+
+
+
+### What did you expect to see?
+
+
+
+### What did you see instead?
+
+

.github/ISSUE_TEMPLATE/01-pkgsite.yml

@@ -1,47 +0,0 @@
-name: Pkg.go.dev bugs or feature requests
-description: Issues or feature requests for the documentation site
-title: "x/pkgsite: issue title"
-labels: ["pkgsite"]
-body:
-  - type: markdown
-    attributes:
-      value: "Please answer these questions before submitting your issue. Thanks!"
-  - type: input
-    id: url
-    attributes:
-      label: "What is the URL of the page with the issue?"
-    validations:
-      required: true
-  - type: input
-    id: user-agent
-    attributes:
-      label: "What is your user agent?"
-      description: "You can find your user agent here: https://www.google.com/search?q=what+is+my+user+agent"
-    validations:
-      required: true
-  - type: textarea
-    id: screenshot
-    attributes:
-      label: "Screenshot"
-      description: "Please paste a screenshot of the page."
-    validations:
-      required: false
-  - type: textarea
-    id: what-did-you-do
-    attributes:
-      label: "What did you do?"
-      description: "If possible, provide a recipe for reproducing the error. Starting with a Private/Incognito tab/window may help rule out problematic browser extensions."
-    validations:
-      required: true
-  - type: textarea
-    id: actual-behavior
-    attributes:
-      label: "What did you see happen?"
-    validations:
-      required: true
-  - type: textarea
-    id: expected-behavior
-    attributes:
-      label: "What did you expect to see?"
-    validations:
-      required: true

.github/ISSUE_TEMPLATE/02-pkgsite-removal.md

@@ -0,0 +1,39 @@
+---
+name: Pkg.go.dev package removal request
+about: Request a package be removed from the documentation site (pkg.go.dev)
+title: "x/pkgsite: package removal request for [type path here]"
+labels: pkgsite
+---
+
+<!--
+Please answer these questions before submitting your issue. Thanks!
+-->
+
+### What is the path of the package that you would like to have removed?
+
+<!---
+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.
+--->
+
+
+
+### Are you the owner of this package?
+
+<!---
+Only the package owners can request to have their packages removed from pkg.go.dev.
+--->
+
+
+
+### What is the reason that you could not retract this package instead?
+
+<!---
+If you would like to have your module removed from pkg.go.dev, we recommend that you retract them, so that they can be removed from the go command and proxy.golang.org as well.
+
+Retracting a module version involves adding a retract directive to your go.mod file and publishing a new version. For example: https://github.com/jba/retract-demo/blob/main/go.mod#L5-L8
+
+See https://pkg.go.dev/about#removing-a-package for additional tips on retractions.
+--->
+
+

.github/ISSUE_TEMPLATE/02-pkgsite-removal.yml

@@ -1,42 +0,0 @@
-name: Pkg.go.dev package removal request
-description: Request a package be removed from the documentation site (pkg.go.dev)
-title: "x/pkgsite: package removal request for [type path here]"
-labels: ["pkgsite/package-removal"]
-body:
-  - type: markdown
-    attributes:
-      value: "Please answer these questions before submitting your issue. Thanks!"
-  - 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
-    attributes:
-      label: "Are you the owner of this package?"
-      description: |
-        Only the package owners can request to have their packages removed from pkg.go.dev.
-        If the package path doesn't include your github username, please provide some other form of proof of ownership.
-    validations:
-      required: true
-  - type: textarea
-    id: retraction-reason
-    attributes:
-      label: "What is the reason that you could not retract this package instead?"
-      description: |
-        Requesting we remove a module here only hides the generated documentation on pkg.go.dev.
-        It does not affect the behaviour of proxy.golang.org or the go command.
-        Instead we recommend using the retract directive which will be processed by all 3 of the above.
-
-        If you have deleted your repo, please recreate it and publish a retraction.
-
-        Retracting a module version involves adding a retract directive to your go.mod file and publishing a new version.
-        For example: https://github.com/jba/retract-demo/blob/main/go.mod#L5-L8.
-        See https://pkg.go.dev/about#removing-a-package for additional tips on retractions.
-    validations:
-      required: true

.github/ISSUE_TEMPLATE/03-gopls.md

@@ -0,0 +1,61 @@
+---
+name: Gopls bugs or feature requests
+about: Issues or feature requests for the Go language server (gopls)
+title: "x/tools/gopls: "
+labels: gopls Tools
+---
+
+<!--
+Please answer these questions before submitting your issue. Thanks!
+-->
+
+### gopls version
+
+<!--
+Output of `gopls -v version` on the command line
+-->
+
+
+
+### go env
+
+<!--
+Output of `go env` on the command line in your workspace directory
+-->
+
+
+### What did you do?
+
+<!--
+If possible, provide a recipe for reproducing the error.
+A complete runnable program is good.
+A link on go.dev/play is better.
+A failing unit test is the best.
+-->
+
+
+
+### What did you expect to see?
+
+
+
+### What did you see instead?
+
+
+
+### Editor and settings
+
+<!--
+Your editor and any settings you have configured (for example, your VSCode settings.json file)
+-->
+
+
+
+### Logs
+
+<!--
+If possible please include gopls logs. Instructions for capturing them can be found here:
+https://github.com/golang/tools/blob/master/gopls/doc/troubleshooting.md#capture-logs
+-->
+
+

.github/ISSUE_TEMPLATE/03-gopls.yml

@@ -1,56 +0,0 @@
-name: Gopls bugs or feature requests
-description: Issues or feature requests for the Go language server (gopls)
-title: "x/tools/gopls: issue title"
-labels: ["gopls", "Tools"]
-body:
-  - type: markdown
-    attributes:
-      value: "Please answer these questions before submitting your issue. Thanks!"
-  - type: textarea
-    id: gopls-version
-    attributes:
-      label: "gopls version"
-      description: "Output of `gopls -v version` on the command line"
-    validations:
-      required: true
-  - type: textarea
-    id: go-env
-    attributes:
-      label: "go env"
-      description: "Output of `go env` on the command line in your workspace directory"
-      render: shell
-    validations:
-      required: true
-  - type: textarea
-    id: what-did-you-do
-    attributes:
-      label: "What did you do?"
-      description: "If possible, provide a recipe for reproducing the error. A complete runnable program is good. A link on [go.dev/play](https://go.dev/play) is better. A failing unit test is the best."
-    validations:
-      required: true
-  - type: textarea
-    id: actual-behavior
-    attributes:
-      label: "What did you see happen?"
-    validations:
-      required: true
-  - type: textarea
-    id: expected-behavior
-    attributes:
-      label: "What did you expect to see?"
-    validations:
-      required: true
-  - type: textarea
-    id: editor-and-settings
-    attributes:
-      label: "Editor and settings"
-      description: "Your editor and any settings you have configured (for example, your VSCode settings.json file)"
-    validations:
-      required: false
-  - type: textarea
-    id: logs
-    attributes:
-      label: "Logs"
-      description: "If possible please include gopls logs. Instructions for capturing them can be found here: https://github.com/golang/tools/blob/master/gopls/doc/troubleshooting.md#capture-logs"
-    validations:
-      required: false

.github/ISSUE_TEMPLATE/04-vuln.yml

@@ -1,52 +0,0 @@
-name: Go vulnerability management - bugs and feature requests
-description: Issues or feature requests about Go vulnerability management
-title: "x/vuln: issue title"
-labels: ["vulncheck or vulndb"]
-body:
-  - type: markdown
-    attributes:
-      value: "Please answer these questions before submitting your issue. Thanks! To add a new vulnerability to the Go vulnerability database (https://vuln.go.dev), see https://go.dev/s/vulndb-report-new. To report an issue about a report, see https://go.dev/s/vulndb-report-feedback."
-  - type: textarea
-    id: govulncheck-version
-    attributes:
-      label: govulncheck version
-      description: What version of govulncheck are you using (`govulncheck -version`)?
-      placeholder: |
-        Go: devel go1.22-0262ea1ff9 Thu Oct 26 18:46:50 2023 +0000
-        Scanner: govulncheck@v1.0.2-0.20231108200754-fcf7dff7b242
-        DB: https://vuln.go.dev
-        DB updated: 2023-11-21 15:39:17 +0000 UTC
-    validations:
-      required: true
-  - type: textarea
-    id: reproduce-latest-version
-    attributes:
-      label: "Does this issue reproduce at the latest version of golang.org/x/vuln?"
-    validations:
-      required: true
-  - type: textarea
-    id: go-env
-    attributes:
-      label: "Output of `go env` in your module/workspace:"
-      render: shell
-    validations:
-      required: true
-  - type: textarea
-    id: what-did-you-do
-    attributes:
-      label: "What did you do?"
-      description: "If possible, provide a recipe for reproducing the error. A complete runnable program is good. A link on [go.dev/play](https://go.dev/play) is best."
-    validations:
-      required: true
-  - type: textarea
-    id: actual-behavior
-    attributes:
-      label: "What did you see happen?"
-    validations:
-      required: true
-  - type: textarea
-    id: expected-behavior
-    attributes:
-      label: "What did you expect to see?"
-    validations:
-      required: true

.github/ISSUE_TEMPLATE/10-proposal.md

@@ -0,0 +1,13 @@
+---
+name: Proposals
+about: New external API or other notable changes
+title: "proposal: affected/package: "
+labels: Proposal
+---
+
+<!--
+Our proposal process is documented here:
+https://go.dev/s/proposal-process
+-->
+
+

.github/ISSUE_TEMPLATE/10-proposal.yml

@@ -1,15 +0,0 @@
-name: Proposals
-description: New external API or other notable changes
-title: "proposal: import/path: proposal title"
-labels: ["Proposal"]
-body:
-  - type: markdown
-    attributes:
-      value: "Our proposal process is documented here: https://go.dev/s/proposal-process"
-  - type: textarea
-    id: proposal-details
-    attributes:
-      label: "Proposal Details"
-      description: "Please provide the details of your proposal here."
-    validations:
-      required: true

.github/ISSUE_TEMPLATE/11-language-change.md

@@ -0,0 +1,52 @@
+---
+name: Language Change Proposals
+about: Changes to the language
+title: "proposal: Go 2: "
+labels: Proposal Go2 LanguageChange
+---
+
+<!--
+Our process for evaluating language changes can be found here:
+https://go.googlesource.com/proposal/+/refs/heads/master#language-changes
+-->
+
+### Author background
+
+- **Would you consider yourself a novice, intermediate, or experienced Go programmer?**
+- **What other languages do you have experience with?**
+
+### Related proposals
+
+- **Has this idea, or one like it, been proposed before?**
+  - **If so, how does this proposal differ?**
+- **Does this affect error handling?**
+  - **If so, how does this differ from previous error handling proposals?**
+- **Is this about generics?**
+  - **If so, how does this relate to the accepted design and other generics proposals?**
+
+### Proposal
+
+- **What is the proposed change?**
+- **Who does this proposal help, and why?**
+- **Please describe as precisely as possible the change to the language.**
+- **What would change in the language spec?**
+- **Please also describe the change informally, as in a class teaching Go.**
+- **Is this change backward compatible?**
+  - Breaking the Go 1 compatibility guarantee is a large cost and requires a large benefit.
+    Show example code before and after the change.
+  - **Before**
+  - **After**
+- **Orthogonality: how does this change interact or overlap with existing features?**
+- **Is the goal of this change a performance improvement?**
+  - **If so, what quantifiable improvement should we expect?**
+  - **How would we measure it?**
+
+### Costs
+
+- **Would this change make Go easier or harder to learn, and why?**
+- **What is the cost of this proposal? (Every language change has a cost).**
+- **How many tools (such as vet, gopls, gofmt, goimports, etc.) would be affected?**
+- **What is the compile time cost?**
+- **What is the run time cost?**
+- **Can you describe a possible implementation?**
+- **Do you have a prototype? (This is not required.)**

.github/ISSUE_TEMPLATE/11-language-change.yml

@@ -1,165 +0,0 @@
-name: Language Change Proposals
-description: Changes to the language
-labels: ["Proposal", "LanguageChange", "LanguageChangeReview"]
-title: "proposal: spec: proposal title"
-
-
-body:
-  - type: markdown
-    attributes:
-      value: |
-       ## Our process for evaluating language changes can be found [here](https://go.googlesource.com/proposal/+/refs/heads/master#language-changes)
-
-  - type: dropdown
-    id: author-go-experience
-    attributes:
-      label: "Go Programming Experience"
-      description: "Would you consider yourself a novice, intermediate, or experienced Go programmer?"
-      options:
-        - "Novice"
-        - "Intermediate"
-        - "Experienced"
-      default: 1
-
-  - type: input
-    id: author-other-languages-experience
-    attributes:
-      label: "Other Languages Experience"
-      description: "What other languages do you have experience with?"
-      placeholder: "Go, Python, JS, Rust"
-    validations:
-      required: false
-
-  - type: checkboxes
-    id: related-idea
-    attributes:
-      label: "Related Idea"
-      options:
-        - label: "Has this idea, or one like it, been proposed before?"
-        - label: "Does this affect error handling?"
-        - label: "Is this about generics?"
-        - label: "Is this change backward compatible? Breaking the Go 1 compatibility guarantee is a large cost and requires a large benefit"
-
-  - type: textarea
-    id: related-proposals
-    attributes:
-      label: Has this idea, or one like it, been proposed before?
-      description: If so, how does this proposal differ?
-      placeholder: |
-       Yes or No
-
-       If yes, 
-        1. Mention the related proposals 
-        2. then describe how this proposal differs       
-    validations:
-      required: true
-
-  - type: textarea
-    id: error-handling-proposal
-    attributes:
-      label: Does this affect error handling?
-      description: If so, how does this differ from previous error handling proposals?
-      placeholder: |
-       Yes or No
-
-       If yes, 
-        1.how does this differ from previous error handling proposals?
-
-    validations:
-      required: true
-
-  - type: textarea
-    id: generics-proposal
-    attributes:
-      label: Is this about generics?
-      description: If so, how does this relate to the accepted design and other generics proposals?
-      placeholder: |
-       Yes or No
-
-       If yes, 
-        1. how does this relate to the accepted design and other generics proposals?
-
-    validations:
-      required: true
-
-  - type: textarea
-    id: proposal
-    attributes:
-      label: "Proposal"
-      description: "What is the proposed change? Who does this proposal help, and why? Please describe as precisely as possible the change to the language."
-    validations:
-      required: true
-
-  - type: textarea
-    id: language-spec-changes
-    attributes:
-      label: "Language Spec Changes"
-      description: "What would change in the language spec?"
-    validations:
-      required: false
-
-  - type: textarea
-    id: informal-change
-    attributes:
-      label: "Informal Change"
-      description: "Please also describe the change informally, as in a class teaching Go."
-    validations:
-      required: false
-
-  - type: textarea
-    id: go-backwards-compatiblity
-    attributes:
-      label: Is this change backward compatible?
-      description: Breaking the Go 1 compatibility guarantee is a large cost and requires a large benefit.
-      placeholder: |
-       Yes or No
-
-       If yes, 
-        1. Show example code before and after the change.
-
-    validations:
-      required: true
-
-  - type: textarea
-    id: orthogonality
-    attributes:
-      label: "Orthogonality: How does this change interact or overlap with existing features?"
-      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:
-      label: "Cost Description"
-      description: "What is the cost of this proposal? (Every language change has a cost)"
-
-  - type: input
-    id: go-toolchain
-    attributes:
-      label: Changes to Go ToolChain
-      description: "How many tools (such as vet, gopls, gofmt, goimports, etc.) would be affected? "
-    validations:
-      required: false
-
-  - type: input
-    id: perf-costs
-    attributes:
-      label: Performance Costs
-      description: "What is the compile time cost? What is the run time cost? "
-    validations:
-      required: false
-
-  - type: textarea
-    id: prototype
-    attributes:
-      label: "Prototype"
-      description: "Can you describe a possible implementation?"
-    validations:
-      required: false
-

.github/ISSUE_TEMPLATE/12-telemetry.yml

@@ -1,30 +0,0 @@
-name: Go Telemetry Proposals
-description: Changes to the telemetry upload configuration
-title: "x/telemetry/config: proposal title"
-labels: ["Telemetry-Proposal"]
-projects: ["golang/29"]
-body:
-- type: textarea
-  attributes:
-    label: Summary
-    description: >
-      What change are you proposing to the upload configuration, and why?
-      For new upload configuration, which new counters will be collected, what
-      do they measure, and why is it important to collect them?
-      Note that uploaded data must not carry sensitive user information.
-      See [go.dev/doc/telemetry#proposals](https://go.dev/doc/telemetry#proposals)
-      for more details on telemetry proposals.
-  validations:
-    required: true
-- type: input
-  attributes:
-    label: Proposed Config Change
-    description: >
-      A CL containing proposed changes to the
-      [config.txt](https://go.googlesource.com/telemetry/+/master/internal/chartconfig/config.txt)
-      chart configuration.
-      See the [chartconfig](https://pkg.go.dev/golang.org/x/telemetry/internal/chartconfig)
-      package for an explanation of the chart config format.
-      For an example change, see [CL 564619](https://go.dev/cl/564619).
-  validations:
-    required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -1,4 +1,4 @@
-blank_issues_enabled: true
+blank_issues_enabled: false
 contact_links:
   - name: Questions
     about: Please use one of the forums for questions or general discussions

.github/SUPPORT.md

@@ -1,5 +1,5 @@
 Unlike many projects on GitHub, the Go project does not use its bug tracker for general discussion or asking questions.
-We only use our bug tracker for tracking bugs and tracking proposals going through the [Proposal Process](https://go.dev/s/proposal-process).
+We only use our bug tracker for tracking bugs and tracking proposals going through the [Proposal Process](https://golang.org/s/proposal-process).
 
 For asking questions, see:
 

.gitignore

@@ -30,17 +30,16 @@ _testmain.go
 /misc/cgo/testso/main
 /pkg/
 /src/*.*/
-/src/_artifacts/
 /src/cmd/cgo/zdefaultcc.go
 /src/cmd/dist/dist
 /src/cmd/go/internal/cfg/zdefaultcc.go
+/src/cmd/go/internal/cfg/zosarch.go
 /src/cmd/internal/objabi/zbootstrap.go
 /src/go/build/zcgo.go
 /src/go/doc/headscan
 /src/internal/buildcfg/zbootstrap.go
-/src/internal/runtime/sys/zversion.go
+/src/runtime/internal/sys/zversion.go
 /src/unicode/maketables
-/src/time/tzdata/zzipdata.go
 /test.out
 /test/garbage/*.out
 /test/pass.out

CONTRIBUTING.md

@@ -24,7 +24,7 @@ Otherwise, when filing an issue, make sure to answer these five questions:
 4. What did you expect to see?
 5. What did you see instead?
 
-For change proposals, see [Proposing Changes To Go](https://go.dev/s/proposal-process).
+For change proposals, see [Proposing Changes To Go](https://github.com/golang/proposal/).
 
 ## Contributing code
 

LICENSE

@@ -1,4 +1,4 @@
-Copyright 2009 The Go Authors.
+Copyright (c) 2009 The Go Authors. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
@@ -10,7 +10,7 @@ notice, this list of conditions and the following disclaimer.
 copyright notice, this list of conditions and the following disclaimer
 in the documentation and/or other materials provided with the
 distribution.
-   * Neither the name of Google LLC nor the names of its
+   * Neither the name of Google Inc. nor the names of its
 contributors may be used to endorse or promote products derived from
 this software without specific prior written permission.
 

README.boringcrypto.md

@@ -0,0 +1,24 @@
+# dev.boringcrypto branch
+
+This branch is no more. `GOEXPERIMENT=boringcrypto` on the standard branch does the job now.
+
+Previous notice:
+
+We have been working inside Google on a fork of Go that uses
+BoringCrypto (the core of [BoringSSL][]) for various crypto
+primitives, in furtherance of some [work related to FIPS 140-2][sp].
+We have heard that some external users of Go would be interested in
+this code as well, so this branch holds the patches to make Go use
+BoringCrypto.
+
+[BoringSSL]: https://boringssl.googlesource.com/boringssl/
+[sp]: https://csrc.nist.gov/CSRC/media/projects/cryptographic-module-validation-program/documents/security-policies/140sp3678.pdf
+
+Unlike typical dev branches, we do not intend any eventual merge of
+this code into the master branch. Instead we intend to maintain in
+this branch the latest release plus BoringCrypto patches.
+
+To be clear, we are not making any statements or representations about
+the suitability of this code in relation to the FIPS 140-2 standard.
+Interested users will have to evaluate for themselves whether the code
+is useful for their own purposes.

README.md

@@ -4,7 +4,7 @@ Go is an open source programming language that makes it easy to build simple,
 reliable, and efficient software.
 
 ![Gopher image](https://golang.org/doc/gopher/fiveyears.jpg)
-*Gopher image by [Renee French][rf], licensed under [Creative Commons 4.0 Attribution license][cc4-by].*
+*Gopher image by [Renee French][rf], licensed under [Creative Commons 3.0 Attributions license][cc3-by].*
 
 Our canonical Git repository is located at https://go.googlesource.com/go.
 There is a mirror of the repository at https://github.com/golang/go.
@@ -39,4 +39,4 @@ proposals only. See https://go.dev/wiki/Questions for a list of
 places to ask questions about the Go language.
 
 [rf]: https://reneefrench.blogspot.com/
-[cc4-by]: https://creativecommons.org/licenses/by/4.0/
+[cc3-by]: https://creativecommons.org/licenses/by/3.0/

SECURITY.md

@@ -10,4 +10,4 @@ part of that page.
 
 ## Reporting a Vulnerability
 
-See https://go.dev/security/policy for how to report a vulnerability.
+See https://go.dev/security for how to report a vulnerability.

api/README

@@ -21,6 +21,3 @@ warning output from the go api tool. Each file should be named
 nnnnn.txt, after the issue number for the accepted proposal.
 (The #nnnnn suffix must also appear at the end of each line in the file;
 that will be preserved when next/*.txt is concatenated into go1.XX.txt.)
-
-When you add a file to the api/next directory, you must add at least one file
-under doc/next. See doc/README.md for details.

api/except.txt

@@ -1,5 +1,3 @@
-pkg crypto/tls, type ConnectionState struct, TLSUnique //deprecated
-pkg debug/elf, const R_PPC64_SECTOFF_LO_DS = 61
 pkg encoding/json, method (*RawMessage) MarshalJSON() ([]uint8, error)
 pkg math, const MaxFloat64 = 1.79769e+308  // 179769313486231570814527423731704356798100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 pkg math, const SmallestNonzeroFloat32 = 1.4013e-45  // 17516230804060213386546619791123951641/12500000000000000000000000000000000000000000000000000000000000000000000000000000000
@@ -502,8 +500,6 @@ pkg text/template/parse, type Node interface { Copy, String, Type }
 pkg unicode, const Version = "10.0.0"
 pkg unicode, const Version = "11.0.0"
 pkg unicode, const Version = "12.0.0"
-pkg unicode, const Version = "13.0.0"
-pkg unicode, const Version = "15.0.0"
 pkg unicode, const Version = "6.2.0"
 pkg unicode, const Version = "6.3.0"
 pkg unicode, const Version = "7.0.0"
@@ -511,95 +507,3 @@ pkg unicode, const Version = "8.0.0"
 pkg unicode, const Version = "9.0.0"
 pkg html/template, method (*Template) Funcs(FuncMap) *Template
 pkg html/template, type FuncMap map[string]interface{}
-pkg syscall (freebsd-386), const SYS_FSTAT = 189
-pkg syscall (freebsd-386), const SYS_FSTATAT = 493
-pkg syscall (freebsd-386), const SYS_FSTATFS = 397
-pkg syscall (freebsd-386), const SYS_GETDIRENTRIES = 196
-pkg syscall (freebsd-386), const SYS_GETFSSTAT = 395
-pkg syscall (freebsd-386), const SYS_LSTAT = 190
-pkg syscall (freebsd-386), const SYS_LSTAT ideal-int
-pkg syscall (freebsd-386), const SYS_MKNODAT = 498
-pkg syscall (freebsd-386), const SYS_STAT = 188
-pkg syscall (freebsd-386), const SYS_STAT ideal-int
-pkg syscall (freebsd-386), const SYS_STATFS = 396
-pkg syscall (freebsd-386-cgo), const SYS_FSTAT = 189
-pkg syscall (freebsd-386-cgo), const SYS_FSTATAT = 493
-pkg syscall (freebsd-386-cgo), const SYS_FSTATFS = 397
-pkg syscall (freebsd-386-cgo), const SYS_GETDIRENTRIES = 196
-pkg syscall (freebsd-386-cgo), const SYS_GETFSSTAT = 395
-pkg syscall (freebsd-386-cgo), const SYS_LSTAT = 190
-pkg syscall (freebsd-386-cgo), const SYS_LSTAT ideal-int
-pkg syscall (freebsd-386-cgo), const SYS_MKNODAT = 498
-pkg syscall (freebsd-386-cgo), const SYS_STAT = 188
-pkg syscall (freebsd-386-cgo), const SYS_STAT ideal-int
-pkg syscall (freebsd-386-cgo), const SYS_STATFS = 396
-pkg syscall (freebsd-amd64), const SYS_FSTAT = 189
-pkg syscall (freebsd-amd64), const SYS_FSTATAT = 493
-pkg syscall (freebsd-amd64), const SYS_FSTATFS = 397
-pkg syscall (freebsd-amd64), const SYS_GETDIRENTRIES = 196
-pkg syscall (freebsd-amd64), const SYS_GETFSSTAT = 395
-pkg syscall (freebsd-amd64), const SYS_LSTAT = 190
-pkg syscall (freebsd-amd64), const SYS_LSTAT ideal-int
-pkg syscall (freebsd-amd64), const SYS_MKNODAT = 498
-pkg syscall (freebsd-amd64), const SYS_STAT = 188
-pkg syscall (freebsd-amd64), const SYS_STAT ideal-int
-pkg syscall (freebsd-amd64), const SYS_STATFS = 396
-pkg syscall (freebsd-amd64-cgo), const SYS_FSTAT = 189
-pkg syscall (freebsd-amd64-cgo), const SYS_FSTATAT = 493
-pkg syscall (freebsd-amd64-cgo), const SYS_FSTATFS = 397
-pkg syscall (freebsd-amd64-cgo), const SYS_GETDIRENTRIES = 196
-pkg syscall (freebsd-amd64-cgo), const SYS_GETFSSTAT = 395
-pkg syscall (freebsd-amd64-cgo), const SYS_LSTAT = 190
-pkg syscall (freebsd-amd64-cgo), const SYS_LSTAT ideal-int
-pkg syscall (freebsd-amd64-cgo), const SYS_MKNODAT = 498
-pkg syscall (freebsd-amd64-cgo), const SYS_STAT = 188
-pkg syscall (freebsd-amd64-cgo), const SYS_STAT ideal-int
-pkg syscall (freebsd-amd64-cgo), const SYS_STATFS = 396
-pkg syscall (freebsd-arm), const SYS_FSTAT = 189
-pkg syscall (freebsd-arm), const SYS_FSTATAT = 493
-pkg syscall (freebsd-arm), const SYS_FSTATFS = 397
-pkg syscall (freebsd-arm), const SYS_GETDIRENTRIES = 196
-pkg syscall (freebsd-arm), const SYS_GETFSSTAT = 395
-pkg syscall (freebsd-arm), const SYS_LSTAT = 190
-pkg syscall (freebsd-arm), const SYS_LSTAT ideal-int
-pkg syscall (freebsd-arm), const SYS_MKNODAT = 498
-pkg syscall (freebsd-arm), const SYS_STAT = 188
-pkg syscall (freebsd-arm), const SYS_STAT ideal-int
-pkg syscall (freebsd-arm), const SYS_STATFS = 396
-pkg syscall (freebsd-arm-cgo), const SYS_FSTAT = 189
-pkg syscall (freebsd-arm-cgo), const SYS_FSTATAT = 493
-pkg syscall (freebsd-arm-cgo), const SYS_FSTATFS = 397
-pkg syscall (freebsd-arm-cgo), const SYS_GETDIRENTRIES = 196
-pkg syscall (freebsd-arm-cgo), const SYS_GETFSSTAT = 395
-pkg syscall (freebsd-arm-cgo), const SYS_LSTAT = 190
-pkg syscall (freebsd-arm-cgo), const SYS_LSTAT ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_MKNODAT = 498
-pkg syscall (freebsd-arm-cgo), const SYS_STAT = 188
-pkg syscall (freebsd-arm-cgo), const SYS_STAT ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_STATFS = 396
-pkg syscall (freebsd-arm64), const SYS_FSTAT = 189
-pkg syscall (freebsd-arm64), const SYS_FSTATAT = 493
-pkg syscall (freebsd-arm64), const SYS_FSTATFS = 397
-pkg syscall (freebsd-arm64), const SYS_GETDIRENTRIES = 196
-pkg syscall (freebsd-arm64), const SYS_GETFSSTAT = 395
-pkg syscall (freebsd-arm64), const SYS_LSTAT = 190
-pkg syscall (freebsd-arm64), const SYS_LSTAT ideal-int
-pkg syscall (freebsd-arm64), const SYS_MKNODAT = 498
-pkg syscall (freebsd-arm64), const SYS_STAT = 188
-pkg syscall (freebsd-arm64), const SYS_STAT ideal-int
-pkg syscall (freebsd-arm64), const SYS_STATFS = 396
-pkg syscall (freebsd-arm64-cgo), const SYS_FSTAT = 189
-pkg syscall (freebsd-arm64-cgo), const SYS_FSTATAT = 493
-pkg syscall (freebsd-arm64-cgo), const SYS_FSTATFS = 397
-pkg syscall (freebsd-arm64-cgo), const SYS_GETDIRENTRIES = 196
-pkg syscall (freebsd-arm64-cgo), const SYS_GETFSSTAT = 395
-pkg syscall (freebsd-arm64-cgo), const SYS_LSTAT = 190
-pkg syscall (freebsd-arm64-cgo), const SYS_LSTAT ideal-int
-pkg syscall (freebsd-arm64-cgo), const SYS_MKNODAT = 498
-pkg syscall (freebsd-arm64-cgo), const SYS_STAT = 188
-pkg syscall (freebsd-arm64-cgo), const SYS_STAT ideal-int
-pkg syscall (freebsd-arm64-cgo), const SYS_STATFS = 396
-pkg syscall (openbsd-386), const ELAST = 91
-pkg syscall (openbsd-386-cgo), const ELAST = 91
-pkg syscall (openbsd-amd64), const ELAST = 91
-pkg syscall (openbsd-amd64-cgo), const ELAST = 91

api/go1.17.txt

@@ -69,12 +69,6 @@ pkg math (darwin-amd64), const MinInt = -9223372036854775808
 pkg math (darwin-amd64-cgo), const MaxInt = 9223372036854775807
 pkg math (darwin-amd64-cgo), const MaxUint = 18446744073709551615
 pkg math (darwin-amd64-cgo), const MinInt = -9223372036854775808
-pkg math (darwin-arm64), const MaxInt = 9223372036854775807
-pkg math (darwin-arm64), const MaxUint = 18446744073709551615
-pkg math (darwin-arm64), const MinInt = -9223372036854775808
-pkg math (darwin-arm64-cgo), const MaxInt = 9223372036854775807
-pkg math (darwin-arm64-cgo), const MaxUint = 18446744073709551615
-pkg math (darwin-arm64-cgo), const MinInt = -9223372036854775808
 pkg math (freebsd-386), const MaxInt = 2147483647
 pkg math (freebsd-386), const MaxUint = 4294967295
 pkg math (freebsd-386), const MinInt = -2147483648
@@ -93,12 +87,6 @@ pkg math (freebsd-arm), const MinInt = -2147483648
 pkg math (freebsd-arm-cgo), const MaxInt = 2147483647
 pkg math (freebsd-arm-cgo), const MaxUint = 4294967295
 pkg math (freebsd-arm-cgo), const MinInt = -2147483648
-pkg math (freebsd-arm64), const MaxInt = 9223372036854775807
-pkg math (freebsd-arm64), const MaxUint = 18446744073709551615
-pkg math (freebsd-arm64), const MinInt = -9223372036854775808
-pkg math (freebsd-arm64-cgo), const MaxInt = 9223372036854775807
-pkg math (freebsd-arm64-cgo), const MaxUint = 18446744073709551615
-pkg math (freebsd-arm64-cgo), const MinInt = -9223372036854775808
 pkg math (linux-386), const MaxInt = 2147483647
 pkg math (linux-386), const MaxUint = 4294967295
 pkg math (linux-386), const MinInt = -2147483648
@@ -174,15 +162,10 @@ pkg reflect, func VisibleFields(Type) []StructField
 pkg reflect, method (Method) IsExported() bool
 pkg reflect, method (StructField) IsExported() bool
 pkg reflect, method (Value) CanConvert(Type) bool
-pkg reflect, method (Value) InterfaceData //deprecated
 pkg runtime/cgo (darwin-amd64-cgo), func NewHandle(interface{}) Handle
 pkg runtime/cgo (darwin-amd64-cgo), method (Handle) Delete()
 pkg runtime/cgo (darwin-amd64-cgo), method (Handle) Value() interface{}
 pkg runtime/cgo (darwin-amd64-cgo), type Handle uintptr
-pkg runtime/cgo (darwin-arm64-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (darwin-arm64-cgo), method (Handle) Delete()
-pkg runtime/cgo (darwin-arm64-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (darwin-arm64-cgo), type Handle uintptr
 pkg runtime/cgo (freebsd-386-cgo), func NewHandle(interface{}) Handle
 pkg runtime/cgo (freebsd-386-cgo), method (Handle) Delete()
 pkg runtime/cgo (freebsd-386-cgo), method (Handle) Value() interface{}
@@ -195,10 +178,6 @@ pkg runtime/cgo (freebsd-arm-cgo), func NewHandle(interface{}) Handle
 pkg runtime/cgo (freebsd-arm-cgo), method (Handle) Delete()
 pkg runtime/cgo (freebsd-arm-cgo), method (Handle) Value() interface{}
 pkg runtime/cgo (freebsd-arm-cgo), type Handle uintptr
-pkg runtime/cgo (freebsd-arm64-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (freebsd-arm64-cgo), method (Handle) Delete()
-pkg runtime/cgo (freebsd-arm64-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (freebsd-arm64-cgo), type Handle uintptr
 pkg runtime/cgo (linux-386-cgo), func NewHandle(interface{}) Handle
 pkg runtime/cgo (linux-386-cgo), method (Handle) Delete()
 pkg runtime/cgo (linux-386-cgo), method (Handle) Value() interface{}
@@ -278,14 +257,8 @@ pkg syscall (openbsd-amd64), const MSG_CMSG_CLOEXEC = 2048
 pkg syscall (openbsd-amd64), const MSG_CMSG_CLOEXEC ideal-int
 pkg syscall (openbsd-amd64-cgo), const MSG_CMSG_CLOEXEC = 2048
 pkg syscall (openbsd-amd64-cgo), const MSG_CMSG_CLOEXEC ideal-int
-pkg syscall (windows-386), func CreateIoCompletionPort //deprecated
-pkg syscall (windows-386), func GetQueuedCompletionStatus //deprecated
-pkg syscall (windows-386), func PostQueuedCompletionStatus //deprecated
 pkg syscall (windows-386), type SysProcAttr struct, AdditionalInheritedHandles []Handle
 pkg syscall (windows-386), type SysProcAttr struct, ParentProcess Handle
-pkg syscall (windows-amd64), func CreateIoCompletionPort //deprecated
-pkg syscall (windows-amd64), func GetQueuedCompletionStatus //deprecated
-pkg syscall (windows-amd64), func PostQueuedCompletionStatus //deprecated
 pkg syscall (windows-amd64), type SysProcAttr struct, AdditionalInheritedHandles []Handle
 pkg syscall (windows-amd64), type SysProcAttr struct, ParentProcess Handle
 pkg testing, method (*B) Setenv(string, string)

api/go1.18.txt

@@ -1,17 +1,14 @@
 pkg bufio, method (*Writer) AvailableBuffer() []uint8
 pkg bufio, method (ReadWriter) AvailableBuffer() []uint8
 pkg bytes, func Cut([]uint8, []uint8) ([]uint8, []uint8, bool)
-pkg bytes, func Title //deprecated
 pkg crypto/tls, method (*Conn) NetConn() net.Conn
-pkg crypto/tls, type Config struct, PreferServerCipherSuites //deprecated
-pkg crypto/x509, method (*CertPool) Subjects //deprecated
 pkg debug/buildinfo, func Read(io.ReaderAt) (*debug.BuildInfo, error)
 pkg debug/buildinfo, func ReadFile(string) (*debug.BuildInfo, error)
 pkg debug/buildinfo, type BuildInfo = debug.BuildInfo
-pkg debug/dwarf, type BasicType struct, DataBitOffset int64
-pkg debug/dwarf, type StructField struct, DataBitOffset int64
 pkg debug/elf, const R_PPC64_RELATIVE = 22
 pkg debug/elf, const R_PPC64_RELATIVE R_PPC64
+pkg debug/dwarf, type BasicType struct, DataBitOffset int64
+pkg debug/dwarf, type StructField struct, DataBitOffset int64
 pkg debug/plan9obj, var ErrNoSymbols error
 pkg go/ast, method (*IndexListExpr) End() token.Pos
 pkg go/ast, method (*IndexListExpr) Pos() token.Pos
@@ -27,7 +24,6 @@ pkg go/token, const TILDE = 88
 pkg go/token, const TILDE Token
 pkg go/types, func Instantiate(*Context, Type, []Type, bool) (Type, error)
 pkg go/types, func NewContext() *Context
-pkg go/types, func NewSignature //deprecated
 pkg go/types, func NewSignatureType(*Var, []*TypeParam, []*TypeParam, *Tuple, *Tuple, bool) *Signature
 pkg go/types, func NewTerm(bool, Type) *Term
 pkg go/types, func NewTypeParam(*TypeName, Type) *TypeParam
@@ -85,7 +81,6 @@ pkg net, method (*UDPConn) ReadFromUDPAddrPort([]uint8) (int, netip.AddrPort, er
 pkg net, method (*UDPConn) ReadMsgUDPAddrPort([]uint8, []uint8) (int, int, int, netip.AddrPort, error)
 pkg net, method (*UDPConn) WriteMsgUDPAddrPort([]uint8, []uint8, netip.AddrPort) (int, int, error)
 pkg net, method (*UDPConn) WriteToUDPAddrPort([]uint8, netip.AddrPort) (int, error)
-pkg net, type Error interface, Temporary //deprecated
 pkg net/http, func MaxBytesHandler(Handler, int64) Handler
 pkg net/http, method (*Cookie) Valid() error
 pkg net/netip, func AddrFrom16([16]uint8) Addr
@@ -179,7 +174,6 @@ pkg runtime/debug, type BuildSetting struct, Key string
 pkg runtime/debug, type BuildSetting struct, Value string
 pkg strings, func Clone(string) string
 pkg strings, func Cut(string, string) (string, string, bool)
-pkg strings, func Title //deprecated
 pkg sync, method (*Mutex) TryLock() bool
 pkg sync, method (*RWMutex) TryLock() bool
 pkg sync, method (*RWMutex) TryRLock() bool
@@ -189,21 +183,7 @@ pkg syscall (freebsd-amd64), type SysProcAttr struct, Pdeathsig Signal
 pkg syscall (freebsd-amd64-cgo), type SysProcAttr struct, Pdeathsig Signal
 pkg syscall (freebsd-arm), type SysProcAttr struct, Pdeathsig Signal
 pkg syscall (freebsd-arm-cgo), type SysProcAttr struct, Pdeathsig Signal
-pkg syscall (freebsd-arm64), type SysProcAttr struct, Pdeathsig Signal
-pkg syscall (freebsd-arm64-cgo), type SysProcAttr struct, Pdeathsig Signal
-pkg syscall (windows-386), func Syscall //deprecated
-pkg syscall (windows-386), func Syscall12 //deprecated
-pkg syscall (windows-386), func Syscall15 //deprecated
-pkg syscall (windows-386), func Syscall18 //deprecated
-pkg syscall (windows-386), func Syscall6 //deprecated
-pkg syscall (windows-386), func Syscall9 //deprecated
 pkg syscall (windows-386), func SyscallN(uintptr, ...uintptr) (uintptr, uintptr, Errno)
-pkg syscall (windows-amd64), func Syscall //deprecated
-pkg syscall (windows-amd64), func Syscall12 //deprecated
-pkg syscall (windows-amd64), func Syscall15 //deprecated
-pkg syscall (windows-amd64), func Syscall18 //deprecated
-pkg syscall (windows-amd64), func Syscall6 //deprecated
-pkg syscall (windows-amd64), func Syscall9 //deprecated
 pkg syscall (windows-amd64), func SyscallN(uintptr, ...uintptr) (uintptr, uintptr, Errno)
 pkg testing, func MainStart(testDeps, []InternalTest, []InternalBenchmark, []InternalFuzzTarget, []InternalExample) *M
 pkg testing, method (*F) Add(...interface{})

api/go1.19.txt

@@ -1,309 +0,0 @@
-pkg crypto/x509, func ParseRevocationList([]uint8) (*RevocationList, error) #50674
-pkg crypto/x509, method (*CertPool) Clone() *CertPool #35044
-pkg crypto/x509, method (*CertPool) Equal(*CertPool) bool #46057
-pkg crypto/x509, method (*RevocationList) CheckSignatureFrom(*Certificate) error #50674
-pkg crypto/x509, type RevocationList struct, AuthorityKeyId []uint8 #50674
-pkg crypto/x509, type RevocationList struct, Extensions []pkix.Extension #50674
-pkg crypto/x509, type RevocationList struct, Issuer pkix.Name #50674
-pkg crypto/x509, type RevocationList struct, Raw []uint8 #50674
-pkg crypto/x509, type RevocationList struct, RawIssuer []uint8 #50674
-pkg crypto/x509, type RevocationList struct, RawTBSRevocationList []uint8 #50674
-pkg crypto/x509, type RevocationList struct, Signature []uint8 #50674
-pkg debug/elf, const EM_LOONGARCH = 258 #46229
-pkg debug/elf, const EM_LOONGARCH Machine #46229
-pkg debug/elf, const R_LARCH_32 = 1 #46229
-pkg debug/elf, const R_LARCH_32 R_LARCH #46229
-pkg debug/elf, const R_LARCH_64 = 2 #46229
-pkg debug/elf, const R_LARCH_64 R_LARCH #46229
-pkg debug/elf, const R_LARCH_ADD16 = 48 #46229
-pkg debug/elf, const R_LARCH_ADD16 R_LARCH #46229
-pkg debug/elf, const R_LARCH_ADD24 = 49 #46229
-pkg debug/elf, const R_LARCH_ADD24 R_LARCH #46229
-pkg debug/elf, const R_LARCH_ADD32 = 50 #46229
-pkg debug/elf, const R_LARCH_ADD32 R_LARCH #46229
-pkg debug/elf, const R_LARCH_ADD64 = 51 #46229
-pkg debug/elf, const R_LARCH_ADD64 R_LARCH #46229
-pkg debug/elf, const R_LARCH_ADD8 = 47 #46229
-pkg debug/elf, const R_LARCH_ADD8 R_LARCH #46229
-pkg debug/elf, const R_LARCH_COPY = 4 #46229
-pkg debug/elf, const R_LARCH_COPY R_LARCH #46229
-pkg debug/elf, const R_LARCH_IRELATIVE = 12 #46229
-pkg debug/elf, const R_LARCH_IRELATIVE R_LARCH #46229
-pkg debug/elf, const R_LARCH_JUMP_SLOT = 5 #46229
-pkg debug/elf, const R_LARCH_JUMP_SLOT R_LARCH #46229
-pkg debug/elf, const R_LARCH_MARK_LA = 20 #46229
-pkg debug/elf, const R_LARCH_MARK_LA R_LARCH #46229
-pkg debug/elf, const R_LARCH_MARK_PCREL = 21 #46229
-pkg debug/elf, const R_LARCH_MARK_PCREL R_LARCH #46229
-pkg debug/elf, const R_LARCH_NONE = 0 #46229
-pkg debug/elf, const R_LARCH_NONE R_LARCH #46229
-pkg debug/elf, const R_LARCH_RELATIVE = 3 #46229
-pkg debug/elf, const R_LARCH_RELATIVE R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_ADD = 35 #46229
-pkg debug/elf, const R_LARCH_SOP_ADD R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_AND = 36 #46229
-pkg debug/elf, const R_LARCH_SOP_AND R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_ASSERT = 30 #46229
-pkg debug/elf, const R_LARCH_SOP_ASSERT R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_IF_ELSE = 37 #46229
-pkg debug/elf, const R_LARCH_SOP_IF_ELSE R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_NOT = 31 #46229
-pkg debug/elf, const R_LARCH_SOP_NOT R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_0_10_10_16_S2 = 45 #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_0_10_10_16_S2 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_0_5_10_16_S2 = 44 #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_0_5_10_16_S2 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_12 = 40 #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_12 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_16 = 41 #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_16 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_16_S2 = 42 #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_16_S2 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_5 = 38 #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_5 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_5_20 = 43 #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_5_20 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_U = 46 #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_U R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_U_10_12 = 39 #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_U_10_12 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_ABSOLUTE = 23 #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_ABSOLUTE R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_DUP = 24 #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_DUP R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_GPREL = 25 #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_GPREL R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_PCREL = 22 #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_PCREL R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_PLT_PCREL = 29 #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_PLT_PCREL R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_TLS_GD = 28 #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_TLS_GD R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_TLS_GOT = 27 #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_TLS_GOT R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_TLS_TPREL = 26 #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_TLS_TPREL R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_SL = 33 #46229
-pkg debug/elf, const R_LARCH_SOP_SL R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_SR = 34 #46229
-pkg debug/elf, const R_LARCH_SOP_SR R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_SUB = 32 #46229
-pkg debug/elf, const R_LARCH_SOP_SUB R_LARCH #46229
-pkg debug/elf, const R_LARCH_SUB16 = 53 #46229
-pkg debug/elf, const R_LARCH_SUB16 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SUB24 = 54 #46229
-pkg debug/elf, const R_LARCH_SUB24 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SUB32 = 55 #46229
-pkg debug/elf, const R_LARCH_SUB32 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SUB64 = 56 #46229
-pkg debug/elf, const R_LARCH_SUB64 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SUB8 = 52 #46229
-pkg debug/elf, const R_LARCH_SUB8 R_LARCH #46229
-pkg debug/elf, const R_LARCH_TLS_DTPMOD32 = 6 #46229
-pkg debug/elf, const R_LARCH_TLS_DTPMOD32 R_LARCH #46229
-pkg debug/elf, const R_LARCH_TLS_DTPMOD64 = 7 #46229
-pkg debug/elf, const R_LARCH_TLS_DTPMOD64 R_LARCH #46229
-pkg debug/elf, const R_LARCH_TLS_DTPREL32 = 8 #46229
-pkg debug/elf, const R_LARCH_TLS_DTPREL32 R_LARCH #46229
-pkg debug/elf, const R_LARCH_TLS_DTPREL64 = 9 #46229
-pkg debug/elf, const R_LARCH_TLS_DTPREL64 R_LARCH #46229
-pkg debug/elf, const R_LARCH_TLS_TPREL32 = 10 #46229
-pkg debug/elf, const R_LARCH_TLS_TPREL32 R_LARCH #46229
-pkg debug/elf, const R_LARCH_TLS_TPREL64 = 11 #46229
-pkg debug/elf, const R_LARCH_TLS_TPREL64 R_LARCH #46229
-pkg debug/elf, method (R_LARCH) GoString() string #46229
-pkg debug/elf, method (R_LARCH) String() string #46229
-pkg debug/elf, type R_LARCH int #46229
-pkg debug/pe, const IMAGE_COMDAT_SELECT_ANY = 2 #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_ANY ideal-int #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_ASSOCIATIVE = 5 #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_ASSOCIATIVE ideal-int #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_EXACT_MATCH = 4 #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_EXACT_MATCH ideal-int #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_LARGEST = 6 #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_LARGEST ideal-int #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_NODUPLICATES = 1 #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_NODUPLICATES ideal-int #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_SAME_SIZE = 3 #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_SAME_SIZE ideal-int #51868
-pkg debug/pe, const IMAGE_FILE_MACHINE_LOONGARCH32 = 25138 #46229
-pkg debug/pe, const IMAGE_FILE_MACHINE_LOONGARCH32 ideal-int #46229
-pkg debug/pe, const IMAGE_FILE_MACHINE_LOONGARCH64 = 25188 #46229
-pkg debug/pe, const IMAGE_FILE_MACHINE_LOONGARCH64 ideal-int #46229
-pkg debug/pe, const IMAGE_SCN_CNT_CODE = 32 #51868
-pkg debug/pe, const IMAGE_SCN_CNT_CODE ideal-int #51868
-pkg debug/pe, const IMAGE_SCN_CNT_INITIALIZED_DATA = 64 #51868
-pkg debug/pe, const IMAGE_SCN_CNT_INITIALIZED_DATA ideal-int #51868
-pkg debug/pe, const IMAGE_SCN_CNT_UNINITIALIZED_DATA = 128 #51868
-pkg debug/pe, const IMAGE_SCN_CNT_UNINITIALIZED_DATA ideal-int #51868
-pkg debug/pe, const IMAGE_SCN_LNK_COMDAT = 4096 #51868
-pkg debug/pe, const IMAGE_SCN_LNK_COMDAT ideal-int #51868
-pkg debug/pe, const IMAGE_SCN_MEM_DISCARDABLE = 33554432 #51868
-pkg debug/pe, const IMAGE_SCN_MEM_DISCARDABLE ideal-int #51868
-pkg debug/pe, const IMAGE_SCN_MEM_EXECUTE = 536870912 #51868
-pkg debug/pe, const IMAGE_SCN_MEM_EXECUTE ideal-int #51868
-pkg debug/pe, const IMAGE_SCN_MEM_READ = 1073741824 #51868
-pkg debug/pe, const IMAGE_SCN_MEM_READ ideal-int #51868
-pkg debug/pe, const IMAGE_SCN_MEM_WRITE = 2147483648 #51868
-pkg debug/pe, const IMAGE_SCN_MEM_WRITE ideal-int #51868
-pkg debug/pe, method (*File) COFFSymbolReadSectionDefAux(int) (*COFFSymbolAuxFormat5, error) #51868
-pkg debug/pe, type COFFSymbolAuxFormat5 struct #51868
-pkg debug/pe, type COFFSymbolAuxFormat5 struct, Checksum uint32 #51868
-pkg debug/pe, type COFFSymbolAuxFormat5 struct, NumLineNumbers uint16 #51868
-pkg debug/pe, type COFFSymbolAuxFormat5 struct, NumRelocs uint16 #51868
-pkg debug/pe, type COFFSymbolAuxFormat5 struct, SecNum uint16 #51868
-pkg debug/pe, type COFFSymbolAuxFormat5 struct, Selection uint8 #51868
-pkg debug/pe, type COFFSymbolAuxFormat5 struct, Size uint32 #51868
-pkg encoding/binary, func AppendUvarint([]uint8, uint64) []uint8 #51644
-pkg encoding/binary, func AppendVarint([]uint8, int64) []uint8 #51644
-pkg encoding/binary, type AppendByteOrder interface { AppendUint16, AppendUint32, AppendUint64, String } #50601
-pkg encoding/binary, type AppendByteOrder interface, AppendUint16([]uint8, uint16) []uint8 #50601
-pkg encoding/binary, type AppendByteOrder interface, AppendUint32([]uint8, uint32) []uint8 #50601
-pkg encoding/binary, type AppendByteOrder interface, AppendUint64([]uint8, uint64) []uint8 #50601
-pkg encoding/binary, type AppendByteOrder interface, String() string #50601
-pkg encoding/csv, method (*Reader) InputOffset() int64 #43401
-pkg encoding/xml, method (*Decoder) InputPos() (int, int) #45628
-pkg flag, func TextVar(encoding.TextUnmarshaler, string, encoding.TextMarshaler, string) #45754
-pkg flag, method (*FlagSet) TextVar(encoding.TextUnmarshaler, string, encoding.TextMarshaler, string) #45754
-pkg fmt, func Append([]uint8, ...interface{}) []uint8 #47579
-pkg fmt, func Appendf([]uint8, string, ...interface{}) []uint8 #47579
-pkg fmt, func Appendln([]uint8, ...interface{}) []uint8 #47579
-pkg go/doc, method (*Package) HTML(string) []uint8 #51082
-pkg go/doc, method (*Package) Markdown(string) []uint8 #51082
-pkg go/doc, method (*Package) Parser() *comment.Parser #51082
-pkg go/doc, method (*Package) Printer() *comment.Printer #51082
-pkg go/doc, method (*Package) Synopsis(string) string #51082
-pkg go/doc, method (*Package) Text(string) []uint8 #51082
-pkg go/doc/comment, func DefaultLookupPackage(string) (string, bool) #51082
-pkg go/doc/comment, method (*DocLink) DefaultURL(string) string #51082
-pkg go/doc/comment, method (*Heading) DefaultID() string #51082
-pkg go/doc/comment, method (*List) BlankBefore() bool #51082
-pkg go/doc/comment, method (*List) BlankBetween() bool #51082
-pkg go/doc/comment, method (*Parser) Parse(string) *Doc #51082
-pkg go/doc/comment, method (*Printer) Comment(*Doc) []uint8 #51082
-pkg go/doc/comment, method (*Printer) HTML(*Doc) []uint8 #51082
-pkg go/doc/comment, method (*Printer) Markdown(*Doc) []uint8 #51082
-pkg go/doc/comment, method (*Printer) Text(*Doc) []uint8 #51082
-pkg go/doc/comment, type Block interface, unexported methods #51082
-pkg go/doc/comment, type Code struct #51082
-pkg go/doc/comment, type Code struct, Text string #51082
-pkg go/doc/comment, type Doc struct #51082
-pkg go/doc/comment, type Doc struct, Content []Block #51082
-pkg go/doc/comment, type Doc struct, Links []*LinkDef #51082
-pkg go/doc/comment, type DocLink struct #51082
-pkg go/doc/comment, type DocLink struct, ImportPath string #51082
-pkg go/doc/comment, type DocLink struct, Name string #51082
-pkg go/doc/comment, type DocLink struct, Recv string #51082
-pkg go/doc/comment, type DocLink struct, Text []Text #51082
-pkg go/doc/comment, type Heading struct #51082
-pkg go/doc/comment, type Heading struct, Text []Text #51082
-pkg go/doc/comment, type Italic string #51082
-pkg go/doc/comment, type Link struct #51082
-pkg go/doc/comment, type Link struct, Auto bool #51082
-pkg go/doc/comment, type Link struct, Text []Text #51082
-pkg go/doc/comment, type Link struct, URL string #51082
-pkg go/doc/comment, type LinkDef struct #51082
-pkg go/doc/comment, type LinkDef struct, Text string #51082
-pkg go/doc/comment, type LinkDef struct, URL string #51082
-pkg go/doc/comment, type LinkDef struct, Used bool #51082
-pkg go/doc/comment, type List struct #51082
-pkg go/doc/comment, type List struct, ForceBlankBefore bool #51082
-pkg go/doc/comment, type List struct, ForceBlankBetween bool #51082
-pkg go/doc/comment, type List struct, Items []*ListItem #51082
-pkg go/doc/comment, type ListItem struct #51082
-pkg go/doc/comment, type ListItem struct, Content []Block #51082
-pkg go/doc/comment, type ListItem struct, Number string #51082
-pkg go/doc/comment, type Paragraph struct #51082
-pkg go/doc/comment, type Paragraph struct, Text []Text #51082
-pkg go/doc/comment, type Parser struct #51082
-pkg go/doc/comment, type Parser struct, LookupPackage func(string) (string, bool) #51082
-pkg go/doc/comment, type Parser struct, LookupSym func(string, string) bool #51082
-pkg go/doc/comment, type Parser struct, Words map[string]string #51082
-pkg go/doc/comment, type Plain string #51082
-pkg go/doc/comment, type Printer struct #51082
-pkg go/doc/comment, type Printer struct, DocLinkBaseURL string #51082
-pkg go/doc/comment, type Printer struct, DocLinkURL func(*DocLink) string #51082
-pkg go/doc/comment, type Printer struct, HeadingID func(*Heading) string #51082
-pkg go/doc/comment, type Printer struct, HeadingLevel int #51082
-pkg go/doc/comment, type Printer struct, TextCodePrefix string #51082
-pkg go/doc/comment, type Printer struct, TextPrefix string #51082
-pkg go/doc/comment, type Printer struct, TextWidth int #51082
-pkg go/doc/comment, type Text interface, unexported methods #51082
-pkg go/types, method (*Func) Origin() *Func #51682
-pkg go/types, method (*Var) Origin() *Var #51682
-pkg hash/maphash, func Bytes(Seed, []uint8) uint64 #42710
-pkg hash/maphash, func String(Seed, string) uint64 #42710
-pkg html/template, method (*Template) Funcs(template.FuncMap) *Template #46121
-pkg html/template, type FuncMap = template.FuncMap #46121
-pkg net/http, method (*MaxBytesError) Error() string #30715
-pkg net/http, type MaxBytesError struct #30715
-pkg net/http, type MaxBytesError struct, Limit int64 #30715
-pkg net/url, func JoinPath(string, ...string) (string, error) #47005
-pkg net/url, method (*URL) JoinPath(...string) *URL #47005
-pkg net/url, type URL struct, OmitHost bool #46059
-pkg os/exec, method (*Cmd) Environ() []string #50599
-pkg os/exec, type Cmd struct, Err error #43724
-pkg os/exec, var ErrDot error #43724
-pkg regexp/syntax, const ErrNestingDepth = "expression nests too deeply" #51684
-pkg regexp/syntax, const ErrNestingDepth ErrorCode #51684
-pkg runtime/debug, func SetMemoryLimit(int64) int64 #48409
-pkg sort, func Find(int, func(int) int) (int, bool) #50340
-pkg sync/atomic, method (*Bool) CompareAndSwap(bool, bool) bool #50860
-pkg sync/atomic, method (*Bool) Load() bool #50860
-pkg sync/atomic, method (*Bool) Store(bool) #50860
-pkg sync/atomic, method (*Bool) Swap(bool) bool #50860
-pkg sync/atomic, method (*Int32) Add(int32) int32 #50860
-pkg sync/atomic, method (*Int32) CompareAndSwap(int32, int32) bool #50860
-pkg sync/atomic, method (*Int32) Load() int32 #50860
-pkg sync/atomic, method (*Int32) Store(int32) #50860
-pkg sync/atomic, method (*Int32) Swap(int32) int32 #50860
-pkg sync/atomic, method (*Int64) Add(int64) int64 #50860
-pkg sync/atomic, method (*Int64) CompareAndSwap(int64, int64) bool #50860
-pkg sync/atomic, method (*Int64) Load() int64 #50860
-pkg sync/atomic, method (*Int64) Store(int64) #50860
-pkg sync/atomic, method (*Int64) Swap(int64) int64 #50860
-pkg sync/atomic, method (*Pointer[$0]) CompareAndSwap(*$0, *$0) bool #50860
-pkg sync/atomic, method (*Pointer[$0]) Load() *$0 #50860
-pkg sync/atomic, method (*Pointer[$0]) Store(*$0) #50860
-pkg sync/atomic, method (*Pointer[$0]) Swap(*$0) *$0 #50860
-pkg sync/atomic, method (*Uint32) Add(uint32) uint32 #50860
-pkg sync/atomic, method (*Uint32) CompareAndSwap(uint32, uint32) bool #50860
-pkg sync/atomic, method (*Uint32) Load() uint32 #50860
-pkg sync/atomic, method (*Uint32) Store(uint32) #50860
-pkg sync/atomic, method (*Uint32) Swap(uint32) uint32 #50860
-pkg sync/atomic, method (*Uint64) Add(uint64) uint64 #50860
-pkg sync/atomic, method (*Uint64) CompareAndSwap(uint64, uint64) bool #50860
-pkg sync/atomic, method (*Uint64) Load() uint64 #50860
-pkg sync/atomic, method (*Uint64) Store(uint64) #50860
-pkg sync/atomic, method (*Uint64) Swap(uint64) uint64 #50860
-pkg sync/atomic, method (*Uintptr) Add(uintptr) uintptr #50860
-pkg sync/atomic, method (*Uintptr) CompareAndSwap(uintptr, uintptr) bool #50860
-pkg sync/atomic, method (*Uintptr) Load() uintptr #50860
-pkg sync/atomic, method (*Uintptr) Store(uintptr) #50860
-pkg sync/atomic, method (*Uintptr) Swap(uintptr) uintptr #50860
-pkg sync/atomic, type Bool struct #50860
-pkg sync/atomic, type Int32 struct #50860
-pkg sync/atomic, type Int64 struct #50860
-pkg sync/atomic, type Pointer[$0 interface{}] struct #50860
-pkg sync/atomic, type Uint32 struct #50860
-pkg sync/atomic, type Uint64 struct #50860
-pkg sync/atomic, type Uintptr struct #50860
-pkg time, method (Duration) Abs() Duration #51414
-pkg time, method (Time) ZoneBounds() (Time, Time) #50062
-pkg crypto/x509, func ParseCRL //deprecated #50674
-pkg crypto/x509, func ParseDERCRL //deprecated #50674
-pkg crypto/x509, method (*Certificate) CheckCRLSignature //deprecated #50674
-pkg crypto/x509, method (*Certificate) CreateCRL //deprecated #50674
-pkg crypto/x509/pkix, type CertificateList //deprecated #50674
-pkg crypto/x509/pkix, type TBSCertificateList //deprecated #50674
-pkg go/doc, func Synopsis //deprecated #51082
-pkg go/doc, func ToHTML //deprecated #51082
-pkg go/doc, func ToText //deprecated #51082
-pkg io/ioutil, func NopCloser //deprecated #42026
-pkg io/ioutil, func ReadAll //deprecated #42026
-pkg io/ioutil, func ReadDir //deprecated #42026
-pkg io/ioutil, func ReadFile //deprecated #42026
-pkg io/ioutil, func TempDir //deprecated #42026
-pkg io/ioutil, func TempFile //deprecated #42026
-pkg io/ioutil, func WriteFile //deprecated #42026
-pkg io/ioutil, var Discard //deprecated #42026

api/go1.21.txt

@@ -1,426 +0,0 @@
-pkg bytes, func ContainsFunc([]uint8, func(int32) bool) bool #54386
-pkg bytes, method (*Buffer) AvailableBuffer() []uint8 #53685
-pkg bytes, method (*Buffer) Available() int #53685
-pkg cmp, func Compare[$0 Ordered]($0, $0) int #59488
-pkg cmp, func Less[$0 Ordered]($0, $0) bool #59488
-pkg cmp, type Ordered interface {} #59488
-pkg context, func AfterFunc(Context, func()) func() bool #57928
-pkg context, func WithDeadlineCause(Context, time.Time, error) (Context, CancelFunc) #56661
-pkg context, func WithoutCancel(Context) Context #40221
-pkg context, func WithTimeoutCause(Context, time.Duration, error) (Context, CancelFunc) #56661
-pkg crypto/elliptic, func GenerateKey //deprecated #52221
-pkg crypto/elliptic, func Marshal //deprecated #52221
-pkg crypto/elliptic, func Unmarshal //deprecated #52221
-pkg crypto/elliptic, method (*CurveParams) Add //deprecated #34648
-pkg crypto/elliptic, method (*CurveParams) Double //deprecated #34648
-pkg crypto/elliptic, method (*CurveParams) IsOnCurve //deprecated #34648
-pkg crypto/elliptic, method (*CurveParams) ScalarBaseMult //deprecated #34648
-pkg crypto/elliptic, method (*CurveParams) ScalarMult //deprecated #34648
-pkg crypto/elliptic, type Curve interface, Add //deprecated #52221
-pkg crypto/elliptic, type Curve interface, Double //deprecated #52221
-pkg crypto/elliptic, type Curve interface, IsOnCurve //deprecated #52221
-pkg crypto/elliptic, type Curve interface, ScalarBaseMult //deprecated #52221
-pkg crypto/elliptic, type Curve interface, ScalarMult //deprecated #52221
-pkg crypto/rsa, func GenerateMultiPrimeKey //deprecated #56921
-pkg crypto/rsa, type PrecomputedValues struct, CRTValues //deprecated #56921
-pkg crypto/tls, const QUICEncryptionLevelApplication = 3 #44886
-pkg crypto/tls, const QUICEncryptionLevelApplication QUICEncryptionLevel #44886
-pkg crypto/tls, const QUICEncryptionLevelEarly = 1 #60107
-pkg crypto/tls, const QUICEncryptionLevelEarly QUICEncryptionLevel #60107
-pkg crypto/tls, const QUICEncryptionLevelHandshake = 2 #44886
-pkg crypto/tls, const QUICEncryptionLevelHandshake QUICEncryptionLevel #44886
-pkg crypto/tls, const QUICEncryptionLevelInitial = 0 #44886
-pkg crypto/tls, const QUICEncryptionLevelInitial QUICEncryptionLevel #44886
-pkg crypto/tls, const QUICHandshakeDone = 7 #44886
-pkg crypto/tls, const QUICHandshakeDone QUICEventKind #44886
-pkg crypto/tls, const QUICNoEvent = 0 #44886
-pkg crypto/tls, const QUICNoEvent QUICEventKind #44886
-pkg crypto/tls, const QUICRejectedEarlyData = 6 #60107
-pkg crypto/tls, const QUICRejectedEarlyData QUICEventKind #60107
-pkg crypto/tls, const QUICSetReadSecret = 1 #44886
-pkg crypto/tls, const QUICSetReadSecret QUICEventKind #44886
-pkg crypto/tls, const QUICSetWriteSecret = 2 #44886
-pkg crypto/tls, const QUICSetWriteSecret QUICEventKind #44886
-pkg crypto/tls, const QUICTransportParameters = 4 #44886
-pkg crypto/tls, const QUICTransportParameters QUICEventKind #44886
-pkg crypto/tls, const QUICTransportParametersRequired = 5 #44886
-pkg crypto/tls, const QUICTransportParametersRequired QUICEventKind #44886
-pkg crypto/tls, const QUICWriteData = 3 #44886
-pkg crypto/tls, const QUICWriteData QUICEventKind #44886
-pkg crypto/tls, func NewResumptionState([]uint8, *SessionState) (*ClientSessionState, error) #60105
-pkg crypto/tls, func ParseSessionState([]uint8) (*SessionState, error) #60105
-pkg crypto/tls, func QUICClient(*QUICConfig) *QUICConn #44886
-pkg crypto/tls, func QUICServer(*QUICConfig) *QUICConn #44886
-pkg crypto/tls, func VersionName(uint16) string #46308
-pkg crypto/tls, method (AlertError) Error() string #44886
-pkg crypto/tls, method (*ClientSessionState) ResumptionState() ([]uint8, *SessionState, error) #60105
-pkg crypto/tls, method (*Config) DecryptTicket([]uint8, ConnectionState) (*SessionState, error) #60105
-pkg crypto/tls, method (*Config) EncryptTicket(ConnectionState, *SessionState) ([]uint8, error) #60105
-pkg crypto/tls, method (*QUICConn) Close() error #44886
-pkg crypto/tls, method (*QUICConn) ConnectionState() ConnectionState #44886
-pkg crypto/tls, method (*QUICConn) HandleData(QUICEncryptionLevel, []uint8) error #44886
-pkg crypto/tls, method (*QUICConn) NextEvent() QUICEvent #44886
-pkg crypto/tls, method (*QUICConn) SendSessionTicket(QUICSessionTicketOptions) error #60107
-pkg crypto/tls, type QUICSessionTicketOptions struct #60107
-pkg crypto/tls, type QUICSessionTicketOptions struct, EarlyData bool #60107
-pkg crypto/tls, method (*QUICConn) SetTransportParameters([]uint8) #44886
-pkg crypto/tls, method (*QUICConn) Start(context.Context) error #44886
-pkg crypto/tls, method (QUICEncryptionLevel) String() string #44886
-pkg crypto/tls, method (*SessionState) Bytes() ([]uint8, error) #60105
-pkg crypto/tls, type AlertError uint8 #44886
-pkg crypto/tls, type Config struct, UnwrapSession func([]uint8, ConnectionState) (*SessionState, error) #60105
-pkg crypto/tls, type Config struct, WrapSession func(ConnectionState, *SessionState) ([]uint8, error) #60105
-pkg crypto/tls, type QUICConfig struct #44886
-pkg crypto/tls, type QUICConfig struct, TLSConfig *Config #44886
-pkg crypto/tls, type QUICConn struct #44886
-pkg crypto/tls, type QUICEncryptionLevel int #44886
-pkg crypto/tls, type QUICEventKind int #44886
-pkg crypto/tls, type QUICEvent struct #44886
-pkg crypto/tls, type QUICEvent struct, Data []uint8 #44886
-pkg crypto/tls, type QUICEvent struct, Kind QUICEventKind #44886
-pkg crypto/tls, type QUICEvent struct, Level QUICEncryptionLevel #44886
-pkg crypto/tls, type QUICEvent struct, Suite uint16 #44886
-pkg crypto/tls, type SessionState struct #60105
-pkg crypto/tls, type SessionState struct, EarlyData bool #60107
-pkg crypto/tls, type SessionState struct, Extra [][]uint8 #60539
-pkg crypto/x509, type RevocationListEntry struct #53573
-pkg crypto/x509, type RevocationListEntry struct, Extensions []pkix.Extension #53573
-pkg crypto/x509, type RevocationListEntry struct, ExtraExtensions []pkix.Extension #53573
-pkg crypto/x509, type RevocationListEntry struct, Raw []uint8 #53573
-pkg crypto/x509, type RevocationListEntry struct, ReasonCode int #53573
-pkg crypto/x509, type RevocationListEntry struct, RevocationTime time.Time #53573
-pkg crypto/x509, type RevocationListEntry struct, SerialNumber *big.Int #53573
-pkg crypto/x509, type RevocationList struct, RevokedCertificateEntries []RevocationListEntry #53573
-pkg crypto/x509, type RevocationList struct, RevokedCertificates //deprecated #53573
-pkg debug/elf, const COMPRESS_ZSTD = 2 #55107
-pkg debug/elf, const COMPRESS_ZSTD CompressionType #55107
-pkg debug/elf, const DF_1_CONFALT = 8192 #56887
-pkg debug/elf, const DF_1_CONFALT DynFlag1 #56887
-pkg debug/elf, const DF_1_DIRECT = 256 #56887
-pkg debug/elf, const DF_1_DIRECT DynFlag1 #56887
-pkg debug/elf, const DF_1_DISPRELDNE = 32768 #56887
-pkg debug/elf, const DF_1_DISPRELDNE DynFlag1 #56887
-pkg debug/elf, const DF_1_DISPRELPND = 65536 #56887
-pkg debug/elf, const DF_1_DISPRELPND DynFlag1 #56887
-pkg debug/elf, const DF_1_EDITED = 2097152 #56887
-pkg debug/elf, const DF_1_EDITED DynFlag1 #56887
-pkg debug/elf, const DF_1_ENDFILTEE = 16384 #56887
-pkg debug/elf, const DF_1_ENDFILTEE DynFlag1 #56887
-pkg debug/elf, const DF_1_GLOBAL = 2 #56887
-pkg debug/elf, const DF_1_GLOBAL DynFlag1 #56887
-pkg debug/elf, const DF_1_GLOBAUDIT = 16777216 #56887
-pkg debug/elf, const DF_1_GLOBAUDIT DynFlag1 #56887
-pkg debug/elf, const DF_1_GROUP = 4 #56887
-pkg debug/elf, const DF_1_GROUP DynFlag1 #56887
-pkg debug/elf, const DF_1_IGNMULDEF = 262144 #56887
-pkg debug/elf, const DF_1_IGNMULDEF DynFlag1 #56887
-pkg debug/elf, const DF_1_INITFIRST = 32 #56887
-pkg debug/elf, const DF_1_INITFIRST DynFlag1 #56887
-pkg debug/elf, const DF_1_INTERPOSE = 1024 #56887
-pkg debug/elf, const DF_1_INTERPOSE DynFlag1 #56887
-pkg debug/elf, const DF_1_KMOD = 268435456 #56887
-pkg debug/elf, const DF_1_KMOD DynFlag1 #56887
-pkg debug/elf, const DF_1_LOADFLTR = 16 #56887
-pkg debug/elf, const DF_1_LOADFLTR DynFlag1 #56887
-pkg debug/elf, const DF_1_NOCOMMON = 1073741824 #56887
-pkg debug/elf, const DF_1_NOCOMMON DynFlag1 #56887
-pkg debug/elf, const DF_1_NODEFLIB = 2048 #56887
-pkg debug/elf, const DF_1_NODEFLIB DynFlag1 #56887
-pkg debug/elf, const DF_1_NODELETE = 8 #56887
-pkg debug/elf, const DF_1_NODELETE DynFlag1 #56887
-pkg debug/elf, const DF_1_NODIRECT = 131072 #56887
-pkg debug/elf, const DF_1_NODIRECT DynFlag1 #56887
-pkg debug/elf, const DF_1_NODUMP = 4096 #56887
-pkg debug/elf, const DF_1_NODUMP DynFlag1 #56887
-pkg debug/elf, const DF_1_NOHDR = 1048576 #56887
-pkg debug/elf, const DF_1_NOHDR DynFlag1 #56887
-pkg debug/elf, const DF_1_NOKSYMS = 524288 #56887
-pkg debug/elf, const DF_1_NOKSYMS DynFlag1 #56887
-pkg debug/elf, const DF_1_NOOPEN = 64 #56887
-pkg debug/elf, const DF_1_NOOPEN DynFlag1 #56887
-pkg debug/elf, const DF_1_NORELOC = 4194304 #56887
-pkg debug/elf, const DF_1_NORELOC DynFlag1 #56887
-pkg debug/elf, const DF_1_NOW = 1 #56887
-pkg debug/elf, const DF_1_NOW DynFlag1 #56887
-pkg debug/elf, const DF_1_ORIGIN = 128 #56887
-pkg debug/elf, const DF_1_ORIGIN DynFlag1 #56887
-pkg debug/elf, const DF_1_PIE = 134217728 #56887
-pkg debug/elf, const DF_1_PIE DynFlag1 #56887
-pkg debug/elf, const DF_1_SINGLETON = 33554432 #56887
-pkg debug/elf, const DF_1_SINGLETON DynFlag1 #56887
-pkg debug/elf, const DF_1_STUB = 67108864 #56887
-pkg debug/elf, const DF_1_STUB DynFlag1 #56887
-pkg debug/elf, const DF_1_SYMINTPOSE = 8388608 #56887
-pkg debug/elf, const DF_1_SYMINTPOSE DynFlag1 #56887
-pkg debug/elf, const DF_1_TRANS = 512 #56887
-pkg debug/elf, const DF_1_TRANS DynFlag1 #56887
-pkg debug/elf, const DF_1_WEAKFILTER = 536870912 #56887
-pkg debug/elf, const DF_1_WEAKFILTER DynFlag1 #56887
-pkg debug/elf, const R_PPC64_REL24_P9NOTOC = 124 #60348
-pkg debug/elf, const R_PPC64_REL24_P9NOTOC R_PPC64 #60348
-pkg debug/elf, method (DynFlag1) GoString() string #56887
-pkg debug/elf, method (DynFlag1) String() string #56887
-pkg debug/elf, method (*File) DynValue(DynTag) ([]uint64, error) #56892
-pkg debug/elf, type DynFlag1 uint32 #56887
-pkg encoding/binary, var NativeEndian nativeEndian #57237
-pkg errors, var ErrUnsupported error #41198
-pkg flag, func BoolFunc(string, string, func(string) error) #53747
-pkg flag, method (*FlagSet) BoolFunc(string, string, func(string) error) #53747
-pkg go/ast, func IsGenerated(*File) bool #28089
-pkg go/ast, func NewPackage //deprecated #52463
-pkg go/ast, type File struct, GoVersion string #59033
-pkg go/ast, type Importer //deprecated #52463
-pkg go/ast, type Object //deprecated #52463
-pkg go/ast, type Package //deprecated #52463
-pkg go/ast, type Scope //deprecated #52463
-pkg go/build/constraint, func GoVersion(Expr) string #59033
-pkg go/build, type Directive struct #56986
-pkg go/build, type Directive struct, Pos token.Position #56986
-pkg go/build, type Directive struct, Text string #56986
-pkg go/build, type Package struct, Directives []Directive #56986
-pkg go/build, type Package struct, TestDirectives []Directive #56986
-pkg go/build, type Package struct, XTestDirectives []Directive #56986
-pkg go/token, method (*File) Lines() []int #57708
-pkg go/types, method (*Package) GoVersion() string #61175
-pkg html/template, const ErrJSTemplate = 12 #59584
-pkg html/template, const ErrJSTemplate ErrorCode #59584
-pkg io/fs, func FormatDirEntry(DirEntry) string #54451
-pkg io/fs, func FormatFileInfo(FileInfo) string #54451
-pkg log/slog, const KindAny = 0 #56345
-pkg log/slog, const KindAny Kind #56345
-pkg log/slog, const KindBool = 1 #56345
-pkg log/slog, const KindBool Kind #56345
-pkg log/slog, const KindDuration = 2 #56345
-pkg log/slog, const KindDuration Kind #56345
-pkg log/slog, const KindFloat64 = 3 #56345
-pkg log/slog, const KindFloat64 Kind #56345
-pkg log/slog, const KindGroup = 8 #56345
-pkg log/slog, const KindGroup Kind #56345
-pkg log/slog, const KindInt64 = 4 #56345
-pkg log/slog, const KindInt64 Kind #56345
-pkg log/slog, const KindLogValuer = 9 #56345
-pkg log/slog, const KindLogValuer Kind #56345
-pkg log/slog, const KindString = 5 #56345
-pkg log/slog, const KindString Kind #56345
-pkg log/slog, const KindTime = 6 #56345
-pkg log/slog, const KindTime Kind #56345
-pkg log/slog, const KindUint64 = 7 #56345
-pkg log/slog, const KindUint64 Kind #56345
-pkg log/slog, const LevelDebug = -4 #56345
-pkg log/slog, const LevelDebug Level #56345
-pkg log/slog, const LevelError = 8 #56345
-pkg log/slog, const LevelError Level #56345
-pkg log/slog, const LevelInfo = 0 #56345
-pkg log/slog, const LevelInfo Level #56345
-pkg log/slog, const LevelKey ideal-string #56345
-pkg log/slog, const LevelKey = "level" #56345
-pkg log/slog, const LevelWarn = 4 #56345
-pkg log/slog, const LevelWarn Level #56345
-pkg log/slog, const MessageKey ideal-string #56345
-pkg log/slog, const MessageKey = "msg" #56345
-pkg log/slog, const SourceKey ideal-string #56345
-pkg log/slog, const SourceKey = "source" #56345
-pkg log/slog, const TimeKey ideal-string #56345
-pkg log/slog, const TimeKey = "time" #56345
-pkg log/slog, func Any(string, interface{}) Attr #56345
-pkg log/slog, func AnyValue(interface{}) Value #56345
-pkg log/slog, func Bool(string, bool) Attr #56345
-pkg log/slog, func BoolValue(bool) Value #56345
-pkg log/slog, func DebugContext(context.Context, string, ...interface{}) #61200
-pkg log/slog, func Debug(string, ...interface{}) #56345
-pkg log/slog, func Default() *Logger #56345
-pkg log/slog, func Duration(string, time.Duration) Attr #56345
-pkg log/slog, func DurationValue(time.Duration) Value #56345
-pkg log/slog, func ErrorContext(context.Context, string, ...interface{}) #61200
-pkg log/slog, func Error(string, ...interface{}) #56345
-pkg log/slog, func Float64(string, float64) Attr #56345
-pkg log/slog, func Float64Value(float64) Value #56345
-pkg log/slog, func Group(string, ...interface{}) Attr #59204
-pkg log/slog, func GroupValue(...Attr) Value #56345
-pkg log/slog, func InfoContext(context.Context, string, ...interface{}) #61200
-pkg log/slog, func Info(string, ...interface{}) #56345
-pkg log/slog, func Int64(string, int64) Attr #56345
-pkg log/slog, func Int64Value(int64) Value #56345
-pkg log/slog, func Int(string, int) Attr #56345
-pkg log/slog, func IntValue(int) Value #56345
-pkg log/slog, func LogAttrs(context.Context, Level, string, ...Attr) #56345
-pkg log/slog, func Log(context.Context, Level, string, ...interface{}) #56345
-pkg log/slog, func New(Handler) *Logger #56345
-pkg log/slog, func NewJSONHandler(io.Writer, *HandlerOptions) *JSONHandler #59339
-pkg log/slog, func NewLogLogger(Handler, Level) *log.Logger #56345
-pkg log/slog, func NewRecord(time.Time, Level, string, uintptr) Record #56345
-pkg log/slog, func NewTextHandler(io.Writer, *HandlerOptions) *TextHandler #59339
-pkg log/slog, func SetDefault(*Logger) #56345
-pkg log/slog, func String(string, string) Attr #56345
-pkg log/slog, func StringValue(string) Value #56345
-pkg log/slog, func Time(string, time.Time) Attr #56345
-pkg log/slog, func TimeValue(time.Time) Value #56345
-pkg log/slog, func Uint64(string, uint64) Attr #56345
-pkg log/slog, func Uint64Value(uint64) Value #56345
-pkg log/slog, func WarnContext(context.Context, string, ...interface{})  #61200
-pkg log/slog, func Warn(string, ...interface{}) #56345
-pkg log/slog, func With(...interface{}) *Logger #56345
-pkg log/slog, method (Attr) Equal(Attr) bool #56345
-pkg log/slog, method (Attr) String() string #56345
-pkg log/slog, method (*JSONHandler) Enabled(context.Context, Level) bool #56345
-pkg log/slog, method (*JSONHandler) Handle(context.Context, Record) error #56345
-pkg log/slog, method (*JSONHandler) WithAttrs([]Attr) Handler #56345
-pkg log/slog, method (*JSONHandler) WithGroup(string) Handler #56345
-pkg log/slog, method (Kind) String() string #56345
-pkg log/slog, method (Level) Level() Level #56345
-pkg log/slog, method (Level) MarshalJSON() ([]uint8, error) #56345
-pkg log/slog, method (Level) MarshalText() ([]uint8, error) #56345
-pkg log/slog, method (Level) String() string #56345
-pkg log/slog, method (*Level) UnmarshalJSON([]uint8) error #56345
-pkg log/slog, method (*Level) UnmarshalText([]uint8) error #56345
-pkg log/slog, method (*LevelVar) Level() Level #56345
-pkg log/slog, method (*LevelVar) MarshalText() ([]uint8, error) #56345
-pkg log/slog, method (*LevelVar) Set(Level) #56345
-pkg log/slog, method (*LevelVar) String() string #56345
-pkg log/slog, method (*LevelVar) UnmarshalText([]uint8) error #56345
-pkg log/slog, method (*Logger) DebugContext(context.Context, string, ...interface{}) #61200
-pkg log/slog, method (*Logger) Debug(string, ...interface{}) #56345
-pkg log/slog, method (*Logger) Enabled(context.Context, Level) bool #56345
-pkg log/slog, method (*Logger) ErrorContext(context.Context, string, ...interface{}) #61200
-pkg log/slog, method (*Logger) Error(string, ...interface{}) #56345
-pkg log/slog, method (*Logger) Handler() Handler #56345
-pkg log/slog, method (*Logger) InfoContext(context.Context, string, ...interface{}) #61200
-pkg log/slog, method (*Logger) Info(string, ...interface{}) #56345
-pkg log/slog, method (*Logger) LogAttrs(context.Context, Level, string, ...Attr) #56345
-pkg log/slog, method (*Logger) Log(context.Context, Level, string, ...interface{}) #56345
-pkg log/slog, method (*Logger) WarnContext(context.Context, string, ...interface{}) #61200
-pkg log/slog, method (*Logger) Warn(string, ...interface{}) #56345
-pkg log/slog, method (*Logger) WithGroup(string) *Logger #56345
-pkg log/slog, method (*Logger) With(...interface{}) *Logger #56345
-pkg log/slog, method (*Record) AddAttrs(...Attr) #56345
-pkg log/slog, method (*Record) Add(...interface{}) #56345
-pkg log/slog, method (Record) Attrs(func(Attr) bool) #59060
-pkg log/slog, method (Record) Clone() Record #56345
-pkg log/slog, method (Record) NumAttrs() int #56345
-pkg log/slog, method (*TextHandler) Enabled(context.Context, Level) bool #56345
-pkg log/slog, method (*TextHandler) Handle(context.Context, Record) error #56345
-pkg log/slog, method (*TextHandler) WithAttrs([]Attr) Handler #56345
-pkg log/slog, method (*TextHandler) WithGroup(string) Handler #56345
-pkg log/slog, method (Value) Any() interface{} #56345
-pkg log/slog, method (Value) Bool() bool #56345
-pkg log/slog, method (Value) Duration() time.Duration #56345
-pkg log/slog, method (Value) Equal(Value) bool #56345
-pkg log/slog, method (Value) Float64() float64 #56345
-pkg log/slog, method (Value) Group() []Attr #56345
-pkg log/slog, method (Value) Int64() int64 #56345
-pkg log/slog, method (Value) Kind() Kind #56345
-pkg log/slog, method (Value) LogValuer() LogValuer #56345
-pkg log/slog, method (Value) Resolve() Value #56345
-pkg log/slog, method (Value) String() string #56345
-pkg log/slog, method (Value) Time() time.Time #56345
-pkg log/slog, method (Value) Uint64() uint64 #56345
-pkg log/slog, type Attr struct #56345
-pkg log/slog, type Attr struct, Key string #56345
-pkg log/slog, type Attr struct, Value Value #56345
-pkg log/slog, type Handler interface, Enabled(context.Context, Level) bool #56345
-pkg log/slog, type Handler interface { Enabled, Handle, WithAttrs, WithGroup } #56345
-pkg log/slog, type Handler interface, Handle(context.Context, Record) error #56345
-pkg log/slog, type Handler interface, WithAttrs([]Attr) Handler #56345
-pkg log/slog, type Handler interface, WithGroup(string) Handler #56345
-pkg log/slog, type HandlerOptions struct #56345
-pkg log/slog, type HandlerOptions struct, AddSource bool #56345
-pkg log/slog, type HandlerOptions struct, Level Leveler #56345
-pkg log/slog, type HandlerOptions struct, ReplaceAttr func([]string, Attr) Attr #56345
-pkg log/slog, type JSONHandler struct #56345
-pkg log/slog, type Kind int #56345
-pkg log/slog, type Leveler interface { Level } #56345
-pkg log/slog, type Leveler interface, Level() Level #56345
-pkg log/slog, type Level int #56345
-pkg log/slog, type LevelVar struct #56345
-pkg log/slog, type Logger struct #56345
-pkg log/slog, type LogValuer interface { LogValue } #56345
-pkg log/slog, type LogValuer interface, LogValue() Value #56345
-pkg log/slog, type Record struct #56345
-pkg log/slog, type Record struct, Level Level #56345
-pkg log/slog, type Record struct, Message string #56345
-pkg log/slog, type Record struct, PC uintptr #56345
-pkg log/slog, type Record struct, Time time.Time #56345
-pkg log/slog, type Source struct #59280
-pkg log/slog, type Source struct, File string #59280
-pkg log/slog, type Source struct, Function string #59280
-pkg log/slog, type Source struct, Line int #59280
-pkg log/slog, type TextHandler struct #56345
-pkg log/slog, type Value struct #56345
-pkg maps, func Clone[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0) $0 #57436
-pkg maps, func Copy[$0 interface{ ~map[$2]$3 }, $1 interface{ ~map[$2]$3 }, $2 comparable, $3 interface{}]($0, $1) #57436
-pkg maps, func DeleteFunc[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0, func($1, $2) bool) #57436
-pkg maps, func Equal[$0 interface{ ~map[$2]$3 }, $1 interface{ ~map[$2]$3 }, $2 comparable, $3 comparable]($0, $1) bool #57436
-pkg maps, func EqualFunc[$0 interface{ ~map[$2]$3 }, $1 interface{ ~map[$2]$4 }, $2 comparable, $3 interface{}, $4 interface{}]($0, $1, func($3, $4) bool) bool #57436
-pkg math/big, method (*Int) Float64() (float64, Accuracy) #56984
-pkg net/http, method (*ProtocolError) Is(error) bool #41198
-pkg net/http, method (*ResponseController) EnableFullDuplex() error #57786
-pkg net/http, var ErrSchemeMismatch error #44855
-pkg net, method (*Dialer) MultipathTCP() bool #56539
-pkg net, method (*Dialer) SetMultipathTCP(bool) #56539
-pkg net, method (*ListenConfig) MultipathTCP() bool #56539
-pkg net, method (*ListenConfig) SetMultipathTCP(bool) #56539
-pkg net, method (*TCPConn) MultipathTCP() (bool, error) #59166
-pkg reflect, method (Value) Clear() #55002
-pkg reflect, type SliceHeader //deprecated #56906
-pkg reflect, type StringHeader //deprecated #56906
-pkg regexp, method (*Regexp) MarshalText() ([]uint8, error) #46159
-pkg regexp, method (*Regexp) UnmarshalText([]uint8) error #46159
-pkg runtime, method (*PanicNilError) Error() string #25448
-pkg runtime, method (*PanicNilError) RuntimeError() #25448
-pkg runtime, method (*Pinner) Pin(interface{}) #46787
-pkg runtime, method (*Pinner) Unpin() #46787
-pkg runtime, type PanicNilError struct #25448
-pkg runtime, type Pinner struct #46787
-pkg slices, func BinarySearch[$0 interface{ ~[]$1 }, $1 cmp.Ordered]($0, $1) (int, bool) #60091
-pkg slices, func BinarySearchFunc[$0 interface{ ~[]$1 }, $1 interface{}, $2 interface{}]($0, $2, func($1, $2) int) (int, bool) #60091
-pkg slices, func Clip[$0 interface{ ~[]$1 }, $1 interface{}]($0) $0 #57433
-pkg slices, func Clone[$0 interface{ ~[]$1 }, $1 interface{}]($0) $0 #57433
-pkg slices, func Compact[$0 interface{ ~[]$1 }, $1 comparable]($0) $0 #57433
-pkg slices, func CompactFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1, $1) bool) $0 #57433
-pkg slices, func Compare[$0 interface{ ~[]$1 }, $1 cmp.Ordered]($0, $0) int #60091
-pkg slices, func CompareFunc[$0 interface{ ~[]$2 }, $1 interface{ ~[]$3 }, $2 interface{}, $3 interface{}]($0, $1, func($2, $3) int) int #60091
-pkg slices, func Contains[$0 interface{ ~[]$1 }, $1 comparable]($0, $1) bool #57433
-pkg slices, func ContainsFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1) bool) bool #57433
-pkg slices, func Delete[$0 interface{ ~[]$1 }, $1 interface{}]($0, int, int) $0 #57433
-pkg slices, func DeleteFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1) bool) $0 #54768
-pkg slices, func Equal[$0 interface{ ~[]$1 }, $1 comparable]($0, $0) bool #57433
-pkg slices, func EqualFunc[$0 interface{ ~[]$2 }, $1 interface{ ~[]$3 }, $2 interface{}, $3 interface{}]($0, $1, func($2, $3) bool) bool #57433
-pkg slices, func Grow[$0 interface{ ~[]$1 }, $1 interface{}]($0, int) $0 #57433
-pkg slices, func Index[$0 interface{ ~[]$1 }, $1 comparable]($0, $1) int #57433
-pkg slices, func IndexFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1) bool) int #57433
-pkg slices, func Insert[$0 interface{ ~[]$1 }, $1 interface{}]($0, int, ...$1) $0 #57433
-pkg slices, func IsSorted[$0 interface{ ~[]$1 }, $1 cmp.Ordered]($0) bool #60091
-pkg slices, func IsSortedFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1, $1) int) bool #60091
-pkg slices, func Max[$0 interface{ ~[]$1 }, $1 cmp.Ordered]($0) $1 #60091
-pkg slices, func MaxFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1, $1) int) $1 #60091
-pkg slices, func Min[$0 interface{ ~[]$1 }, $1 cmp.Ordered]($0) $1 #60091
-pkg slices, func MinFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1, $1) int) $1 #60091
-pkg slices, func Replace[$0 interface{ ~[]$1 }, $1 interface{}]($0, int, int, ...$1) $0 #57433
-pkg slices, func Reverse[$0 interface{ ~[]$1 }, $1 interface{}]($0) #58565
-pkg slices, func Sort[$0 interface{ ~[]$1 }, $1 cmp.Ordered]($0) #60091
-pkg slices, func SortFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1, $1) int) #60091
-pkg slices, func SortStableFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1, $1) int) #60091
-pkg strings, func ContainsFunc(string, func(int32) bool) bool #54386
-pkg sync, func OnceFunc(func()) func() #56102
-pkg sync, func OnceValue[$0 interface{}](func() $0) func() $0 #56102
-pkg sync, func OnceValues[$0 interface{}, $1 interface{}](func() ($0, $1)) func() ($0, $1) #56102
-pkg syscall (freebsd-386-cgo), type SysProcAttr struct, Jail int #46259
-pkg syscall (freebsd-386), type SysProcAttr struct, Jail int #46259
-pkg syscall (freebsd-amd64-cgo), type SysProcAttr struct, Jail int #46259
-pkg syscall (freebsd-amd64), type SysProcAttr struct, Jail int #46259
-pkg syscall (freebsd-arm64-cgo), type SysProcAttr struct, Jail int #46259
-pkg syscall (freebsd-arm64), type SysProcAttr struct, Jail int #46259
-pkg syscall (freebsd-arm-cgo), type SysProcAttr struct, Jail int #46259
-pkg syscall (freebsd-arm), type SysProcAttr struct, Jail int #46259
-pkg syscall (freebsd-riscv64-cgo), type SysProcAttr struct, Jail int #46259
-pkg syscall (freebsd-riscv64), type SysProcAttr struct, Jail int #46259
-pkg testing, func Testing() bool #52600
-pkg testing/slogtest, func TestHandler(slog.Handler, func() []map[string]interface{}) error #56345
-pkg unicode, const Version = "15.0.0" #55079
-pkg unicode, var Cypro_Minoan *RangeTable #55079
-pkg unicode, var Kawi *RangeTable #55079
-pkg unicode, var Nag_Mundari *RangeTable #55079
-pkg unicode, var Old_Uyghur *RangeTable #55079
-pkg unicode, var Tangsa *RangeTable #55079
-pkg unicode, var Toto *RangeTable #55079
-pkg unicode, var Vithkuqi *RangeTable #55079

api/go1.22.txt

@@ -1,135 +0,0 @@
-pkg archive/tar, method (*Writer) AddFS(fs.FS) error #58000
-pkg archive/zip, method (*Writer) AddFS(fs.FS) error #54898
-pkg cmp, func Or[$0 comparable](...$0) $0 #60204
-pkg crypto/x509, func OIDFromInts([]uint64) (OID, error) #60665
-pkg crypto/x509, method (*CertPool) AddCertWithConstraint(*Certificate, func([]*Certificate) error) #57178
-pkg crypto/x509, method (OID) Equal(OID) bool #60665
-pkg crypto/x509, method (OID) EqualASN1OID(asn1.ObjectIdentifier) bool #60665
-pkg crypto/x509, method (OID) String() string #60665
-pkg crypto/x509, type Certificate struct, Policies []OID #60665
-pkg crypto/x509, type OID struct #60665
-pkg database/sql, method (*Null[$0]) Scan(interface{}) error #60370
-pkg database/sql, method (Null[$0]) Value() (driver.Value, error) #60370
-pkg database/sql, type Null[$0 interface{}] struct #60370
-pkg database/sql, type Null[$0 interface{}] struct, V $0 #60370
-pkg database/sql, type Null[$0 interface{}] struct, Valid bool #60370
-pkg debug/elf, const R_LARCH_64_PCREL = 109 #63725
-pkg debug/elf, const R_LARCH_64_PCREL R_LARCH #63725
-pkg debug/elf, const R_LARCH_ADD6 = 105 #63725
-pkg debug/elf, const R_LARCH_ADD6 R_LARCH #63725
-pkg debug/elf, const R_LARCH_ADD_ULEB128 = 107 #63725
-pkg debug/elf, const R_LARCH_ADD_ULEB128 R_LARCH #63725
-pkg debug/elf, const R_LARCH_ALIGN = 102 #63725
-pkg debug/elf, const R_LARCH_ALIGN R_LARCH #63725
-pkg debug/elf, const R_LARCH_CFA = 104 #63725
-pkg debug/elf, const R_LARCH_CFA R_LARCH #63725
-pkg debug/elf, const R_LARCH_DELETE = 101 #63725
-pkg debug/elf, const R_LARCH_DELETE R_LARCH #63725
-pkg debug/elf, const R_LARCH_PCREL20_S2 = 103 #63725
-pkg debug/elf, const R_LARCH_PCREL20_S2 R_LARCH #63725
-pkg debug/elf, const R_LARCH_SUB6 = 106 #63725
-pkg debug/elf, const R_LARCH_SUB6 R_LARCH #63725
-pkg debug/elf, const R_LARCH_SUB_ULEB128 = 108 #63725
-pkg debug/elf, const R_LARCH_SUB_ULEB128 R_LARCH #63725
-pkg debug/elf, const R_MIPS_PC32 = 248 #61974
-pkg debug/elf, const R_MIPS_PC32 R_MIPS #61974
-pkg encoding/base32, method (*Encoding) AppendDecode([]uint8, []uint8) ([]uint8, error) #53693
-pkg encoding/base32, method (*Encoding) AppendEncode([]uint8, []uint8) []uint8 #53693
-pkg encoding/base64, method (*Encoding) AppendDecode([]uint8, []uint8) ([]uint8, error) #53693
-pkg encoding/base64, method (*Encoding) AppendEncode([]uint8, []uint8) []uint8 #53693
-pkg encoding/hex, func AppendDecode([]uint8, []uint8) ([]uint8, error) #53693
-pkg encoding/hex, func AppendEncode([]uint8, []uint8) []uint8 #53693
-pkg go/ast, func NewPackage //deprecated #52463
-pkg go/ast, func Unparen(Expr) Expr #60061
-pkg go/ast, type Importer //deprecated #52463
-pkg go/ast, type Object //deprecated #52463
-pkg go/ast, type Package //deprecated #52463
-pkg go/ast, type Scope //deprecated #52463
-pkg go/types, func NewAlias(*TypeName, Type) *Alias #63223
-pkg go/types, func Unalias(Type) Type #63223
-pkg go/types, method (*Alias) Obj() *TypeName #63223
-pkg go/types, method (*Alias) String() string #63223
-pkg go/types, method (*Alias) Underlying() Type #63223
-pkg go/types, method (*Info) PkgNameOf(*ast.ImportSpec) *PkgName #62037
-pkg go/types, method (Checker) PkgNameOf(*ast.ImportSpec) *PkgName #62037
-pkg go/types, type Alias struct #63223
-pkg go/types, type Info struct, FileVersions map[*ast.File]string #62605
-pkg go/version, func Compare(string, string) int #62039
-pkg go/version, func IsValid(string) bool #62039
-pkg go/version, func Lang(string) string #62039
-pkg html/template, const ErrJSTemplate //deprecated #61619
-pkg io, method (*SectionReader) Outer() (ReaderAt, int64, int64) #61870
-pkg log/slog, func SetLogLoggerLevel(Level) Level #62418
-pkg math/big, method (*Rat) FloatPrec() (int, bool) #50489
-pkg math/rand/v2, func ExpFloat64() float64 #61716
-pkg math/rand/v2, func Float32() float32 #61716
-pkg math/rand/v2, func Float64() float64 #61716
-pkg math/rand/v2, func Int() int #61716
-pkg math/rand/v2, func Int32() int32 #61716
-pkg math/rand/v2, func Int32N(int32) int32 #61716
-pkg math/rand/v2, func Int64() int64 #61716
-pkg math/rand/v2, func Int64N(int64) int64 #61716
-pkg math/rand/v2, func IntN(int) int #61716
-pkg math/rand/v2, func N[$0 intType]($0) $0 #61716
-pkg math/rand/v2, func New(Source) *Rand #61716
-pkg math/rand/v2, func NewChaCha8([32]uint8) *ChaCha8 #61716
-pkg math/rand/v2, func NewPCG(uint64, uint64) *PCG #61716
-pkg math/rand/v2, func NewZipf(*Rand, float64, float64, uint64) *Zipf #61716
-pkg math/rand/v2, func NormFloat64() float64 #61716
-pkg math/rand/v2, func Perm(int) []int #61716
-pkg math/rand/v2, func Shuffle(int, func(int, int)) #61716
-pkg math/rand/v2, func Uint32() uint32 #61716
-pkg math/rand/v2, func Uint32N(uint32) uint32 #61716
-pkg math/rand/v2, func Uint64() uint64 #61716
-pkg math/rand/v2, func Uint64N(uint64) uint64 #61716
-pkg math/rand/v2, func UintN(uint) uint #61716
-pkg math/rand/v2, method (*ChaCha8) MarshalBinary() ([]uint8, error) #61716
-pkg math/rand/v2, method (*ChaCha8) Seed([32]uint8) #61716
-pkg math/rand/v2, method (*ChaCha8) Uint64() uint64 #61716
-pkg math/rand/v2, method (*ChaCha8) UnmarshalBinary([]uint8) error #61716
-pkg math/rand/v2, method (*PCG) MarshalBinary() ([]uint8, error) #61716
-pkg math/rand/v2, method (*PCG) Seed(uint64, uint64) #61716
-pkg math/rand/v2, method (*PCG) Uint64() uint64 #61716
-pkg math/rand/v2, method (*PCG) UnmarshalBinary([]uint8) error #61716
-pkg math/rand/v2, method (*Rand) ExpFloat64() float64 #61716
-pkg math/rand/v2, method (*Rand) Float32() float32 #61716
-pkg math/rand/v2, method (*Rand) Float64() float64 #61716
-pkg math/rand/v2, method (*Rand) Int() int #61716
-pkg math/rand/v2, method (*Rand) Int32() int32 #61716
-pkg math/rand/v2, method (*Rand) Int32N(int32) int32 #61716
-pkg math/rand/v2, method (*Rand) Int64() int64 #61716
-pkg math/rand/v2, method (*Rand) Int64N(int64) int64 #61716
-pkg math/rand/v2, method (*Rand) IntN(int) int #61716
-pkg math/rand/v2, method (*Rand) NormFloat64() float64 #61716
-pkg math/rand/v2, method (*Rand) Perm(int) []int #61716
-pkg math/rand/v2, method (*Rand) Shuffle(int, func(int, int)) #61716
-pkg math/rand/v2, method (*Rand) Uint32() uint32 #61716
-pkg math/rand/v2, method (*Rand) Uint32N(uint32) uint32 #61716
-pkg math/rand/v2, method (*Rand) Uint64() uint64 #61716
-pkg math/rand/v2, method (*Rand) Uint64N(uint64) uint64 #61716
-pkg math/rand/v2, method (*Rand) UintN(uint) uint #61716
-pkg math/rand/v2, method (*Zipf) Uint64() uint64 #61716
-pkg math/rand/v2, type ChaCha8 struct #61716
-pkg math/rand/v2, type PCG struct #61716
-pkg math/rand/v2, type Rand struct #61716
-pkg math/rand/v2, type Source interface { Uint64 } #61716
-pkg math/rand/v2, type Source interface, Uint64() uint64 #61716
-pkg math/rand/v2, type Zipf struct #61716
-pkg net, method (*TCPConn) WriteTo(io.Writer) (int64, error) #58808
-pkg net/http, func FileServerFS(fs.FS) Handler #51971
-pkg net/http, func NewFileTransportFS(fs.FS) RoundTripper #51971
-pkg net/http, func ServeFileFS(ResponseWriter, *Request, fs.FS, string) #51971
-pkg net/http, method (*Request) PathValue(string) string #61410
-pkg net/http, method (*Request) SetPathValue(string, string) #61410
-pkg net/netip, method (AddrPort) Compare(AddrPort) int #61642
-pkg os, method (*File) WriteTo(io.Writer) (int64, error) #58808
-pkg reflect, func PtrTo //deprecated #59599
-pkg reflect, func TypeFor[$0 interface{}]() Type #60088
-pkg slices, func Concat[$0 interface{ ~[]$1 }, $1 interface{}](...$0) $0 #56353
-pkg syscall (linux-386), type SysProcAttr struct, PidFD *int #51246
-pkg syscall (linux-386-cgo), type SysProcAttr struct, PidFD *int #51246
-pkg syscall (linux-amd64), type SysProcAttr struct, PidFD *int #51246
-pkg syscall (linux-amd64-cgo), type SysProcAttr struct, PidFD *int #51246
-pkg syscall (linux-arm), type SysProcAttr struct, PidFD *int #51246
-pkg syscall (linux-arm-cgo), type SysProcAttr struct, PidFD *int #51246
-pkg testing/slogtest, func Run(*testing.T, func(*testing.T) slog.Handler, func(*testing.T) map[string]interface{}) #61758

api/go1.23.txt

@@ -1,158 +0,0 @@
-pkg archive/tar, type FileInfoNames interface { Gname, IsDir, ModTime, Mode, Name, Size, Sys, Uname } #50102
-pkg archive/tar, type FileInfoNames interface, Gname() (string, error) #50102
-pkg archive/tar, type FileInfoNames interface, IsDir() bool #50102
-pkg archive/tar, type FileInfoNames interface, ModTime() time.Time #50102
-pkg archive/tar, type FileInfoNames interface, Mode() fs.FileMode #50102
-pkg archive/tar, type FileInfoNames interface, Name() string #50102
-pkg archive/tar, type FileInfoNames interface, Size() int64 #50102
-pkg archive/tar, type FileInfoNames interface, Sys() interface{} #50102
-pkg archive/tar, type FileInfoNames interface, Uname() (string, error) #50102
-pkg crypto/tls, const QUICResumeSession = 8 #63691
-pkg crypto/tls, const QUICResumeSession QUICEventKind #63691
-pkg crypto/tls, const QUICStoreSession = 9 #63691
-pkg crypto/tls, const QUICStoreSession QUICEventKind #63691
-pkg crypto/tls, method (*ECHRejectionError) Error() string #63369
-pkg crypto/tls, method (*QUICConn) StoreSession(*SessionState) error #63691
-pkg crypto/tls, type Config struct, EncryptedClientHelloConfigList []uint8 #63369
-pkg crypto/tls, type Config struct, EncryptedClientHelloRejectionVerify func(ConnectionState) error #63369
-pkg crypto/tls, type ConnectionState struct, ECHAccepted bool #63369
-pkg crypto/tls, type ECHRejectionError struct #63369
-pkg crypto/tls, type ECHRejectionError struct, RetryConfigList []uint8 #63369
-pkg crypto/tls, type QUICConfig struct, EnableSessionEvents bool #63691
-pkg crypto/tls, type QUICEvent struct, SessionState *SessionState #63691
-pkg crypto/tls, type QUICSessionTicketOptions struct, Extra [][]uint8 #63691
-pkg crypto/x509, func ParseOID(string) (OID, error) #66249
-pkg crypto/x509, method (*OID) UnmarshalBinary([]uint8) error #66249
-pkg crypto/x509, method (*OID) UnmarshalText([]uint8) error #66249
-pkg crypto/x509, method (OID) MarshalBinary() ([]uint8, error) #66249
-pkg crypto/x509, method (OID) MarshalText() ([]uint8, error) #66249
-pkg debug/elf, const PT_OPENBSD_NOBTCFI = 1705237480 #66054
-pkg debug/elf, const PT_OPENBSD_NOBTCFI ProgType #66054
-pkg debug/elf, const STT_GNU_IFUNC = 10 #66836
-pkg debug/elf, const STT_GNU_IFUNC SymType #66836
-pkg debug/elf, const STT_RELC = 8 #66836
-pkg debug/elf, const STT_RELC SymType #66836
-pkg debug/elf, const STT_SRELC = 9 #66836
-pkg debug/elf, const STT_SRELC SymType #66836
-pkg encoding/binary, func Append([]uint8, ByteOrder, interface{}) ([]uint8, error) #60023
-pkg encoding/binary, func Decode([]uint8, ByteOrder, interface{}) (int, error) #60023
-pkg encoding/binary, func Encode([]uint8, ByteOrder, interface{}) (int, error) #60023
-pkg go/ast, func Preorder(Node) iter.Seq[Node] #66339
-pkg go/types, method (*Alias) Origin() *Alias #67143
-pkg go/types, method (*Alias) Rhs() Type #66559
-pkg go/types, method (*Alias) SetTypeParams([]*TypeParam) #67143
-pkg go/types, method (*Alias) TypeArgs() *TypeList #67143
-pkg go/types, method (*Alias) TypeParams() *TypeParamList #67143
-pkg go/types, method (*Func) Signature() *Signature #65772
-pkg iter, func Pull2[$0 interface{}, $1 interface{}](Seq2[$0, $1]) (func() ($0, $1, bool), func()) #61897
-pkg iter, func Pull[$0 interface{}](Seq[$0]) (func() ($0, bool), func()) #61897
-pkg iter, type Seq2[$0 interface{}, $1 interface{}] func(func($0, $1) bool) #61897
-pkg iter, type Seq[$0 interface{}] func(func($0) bool) #61897
-pkg maps, func All[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0) iter.Seq2[$1, $2] #61900
-pkg maps, func Collect[$0 comparable, $1 interface{}](iter.Seq2[$0, $1]) map[$0]$1 #61900
-pkg maps, func Insert[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0, iter.Seq2[$1, $2]) #61900
-pkg maps, func Keys[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0) iter.Seq[$1] #61900
-pkg maps, func Values[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0) iter.Seq[$2] #61900
-pkg math/rand/v2, func Uint() uint #61716
-pkg math/rand/v2, method (*ChaCha8) Read([]uint8) (int, error) #67059
-pkg math/rand/v2, method (*Rand) Uint() uint #61716
-pkg net, method (*DNSError) Unwrap() error #63116
-pkg net, method (*TCPConn) SetKeepAliveConfig(KeepAliveConfig) error #62254
-pkg net, type DNSError struct, UnwrapErr error #63116
-pkg net, type Dialer struct, KeepAliveConfig KeepAliveConfig #62254
-pkg net, type KeepAliveConfig struct #62254
-pkg net, type KeepAliveConfig struct, Count int #62254
-pkg net, type KeepAliveConfig struct, Enable bool #62254
-pkg net, type KeepAliveConfig struct, Idle time.Duration #62254
-pkg net, type KeepAliveConfig struct, Interval time.Duration #62254
-pkg net, type ListenConfig struct, KeepAliveConfig KeepAliveConfig #62254
-pkg net/http, func ParseCookie(string) ([]*Cookie, error) #66008
-pkg net/http, func ParseSetCookie(string) (*Cookie, error) #66008
-pkg net/http, method (*Request) CookiesNamed(string) []*Cookie #61472
-pkg net/http, type Cookie struct, Partitioned bool #62490
-pkg net/http, type Cookie struct, Quoted bool #46443
-pkg net/http, type Request struct, Pattern string #66405
-pkg net/http/httptest, func NewRequestWithContext(context.Context, string, string, io.Reader) *http.Request #59473
-pkg os, func CopyFS(string, fs.FS) error #62484
-pkg path/filepath, func Localize(string) (string, error) #57151
-pkg reflect, func SliceAt(Type, unsafe.Pointer, int) Value #61308
-pkg reflect, method (Value) Seq() iter.Seq[Value] #66056
-pkg reflect, method (Value) Seq2() iter.Seq2[Value, Value] #66056
-pkg reflect, type Type interface, CanSeq() bool #66056
-pkg reflect, type Type interface, CanSeq2() bool #66056
-pkg reflect, type Type interface, OverflowComplex(complex128) bool #60427
-pkg reflect, type Type interface, OverflowFloat(float64) bool #60427
-pkg reflect, type Type interface, OverflowInt(int64) bool #60427
-pkg reflect, type Type interface, OverflowUint(uint64) bool #60427
-pkg runtime/debug, func SetCrashOutput(*os.File, CrashOptions) error #42888
-pkg runtime/debug, type CrashOptions struct #67182
-pkg slices, func All[$0 interface{ ~[]$1 }, $1 interface{}]($0) iter.Seq2[int, $1] #61899
-pkg slices, func AppendSeq[$0 interface{ ~[]$1 }, $1 interface{}]($0, iter.Seq[$1]) $0 #61899
-pkg slices, func Backward[$0 interface{ ~[]$1 }, $1 interface{}]($0) iter.Seq2[int, $1] #61899
-pkg slices, func Chunk[$0 interface{ ~[]$1 }, $1 interface{}]($0, int) iter.Seq[$0] #53987
-pkg slices, func Collect[$0 interface{}](iter.Seq[$0]) []$0 #61899
-pkg slices, func Repeat[$0 interface{ ~[]$1 }, $1 interface{}]($0, int) $0 #65238
-pkg slices, func SortedFunc[$0 interface{}](iter.Seq[$0], func($0, $0) int) []$0 #61899
-pkg slices, func SortedStableFunc[$0 interface{}](iter.Seq[$0], func($0, $0) int) []$0 #61899
-pkg slices, func Sorted[$0 cmp.Ordered](iter.Seq[$0]) []$0 #61899
-pkg slices, func Values[$0 interface{ ~[]$1 }, $1 interface{}]($0) iter.Seq[$1] #61899
-pkg structs, type HostLayout struct #66408
-pkg sync, method (*Map) Clear() #61696
-pkg sync/atomic, func AndInt32(*int32, int32) int32 #61395
-pkg sync/atomic, func AndInt64(*int64, int64) int64 #61395
-pkg sync/atomic, func AndUint32(*uint32, uint32) uint32 #61395
-pkg sync/atomic, func AndUint64(*uint64, uint64) uint64 #61395
-pkg sync/atomic, func AndUintptr(*uintptr, uintptr) uintptr #61395
-pkg sync/atomic, func OrInt32(*int32, int32) int32 #61395
-pkg sync/atomic, func OrInt64(*int64, int64) int64 #61395
-pkg sync/atomic, func OrUint32(*uint32, uint32) uint32 #61395
-pkg sync/atomic, func OrUint64(*uint64, uint64) uint64 #61395
-pkg sync/atomic, func OrUintptr(*uintptr, uintptr) uintptr #61395
-pkg sync/atomic, method (*Int32) And(int32) int32 #61395
-pkg sync/atomic, method (*Int32) Or(int32) int32 #61395
-pkg sync/atomic, method (*Int64) And(int64) int64 #61395
-pkg sync/atomic, method (*Int64) Or(int64) int64 #61395
-pkg sync/atomic, method (*Uint32) And(uint32) uint32 #61395
-pkg sync/atomic, method (*Uint32) Or(uint32) uint32 #61395
-pkg sync/atomic, method (*Uint64) And(uint64) uint64 #61395
-pkg sync/atomic, method (*Uint64) Or(uint64) uint64 #61395
-pkg sync/atomic, method (*Uintptr) And(uintptr) uintptr #61395
-pkg sync/atomic, method (*Uintptr) Or(uintptr) uintptr #61395
-pkg syscall (openbsd-386), const EBADMSG = 92 #67998
-pkg syscall (openbsd-386), const ELAST = 95 #67998
-pkg syscall (openbsd-386), const ENOTRECOVERABLE = 93 #67998
-pkg syscall (openbsd-386), const ENOTRECOVERABLE Errno #67998
-pkg syscall (openbsd-386), const EOWNERDEAD = 94 #67998
-pkg syscall (openbsd-386), const EOWNERDEAD Errno #67998
-pkg syscall (openbsd-386), const EPROTO = 95 #67998
-pkg syscall (openbsd-386-cgo), const EBADMSG = 92 #67998
-pkg syscall (openbsd-386-cgo), const ELAST = 95 #67998
-pkg syscall (openbsd-386-cgo), const ENOTRECOVERABLE = 93 #67998
-pkg syscall (openbsd-386-cgo), const ENOTRECOVERABLE Errno #67998
-pkg syscall (openbsd-386-cgo), const EOWNERDEAD = 94 #67998
-pkg syscall (openbsd-386-cgo), const EOWNERDEAD Errno #67998
-pkg syscall (openbsd-386-cgo), const EPROTO = 95 #67998
-pkg syscall (openbsd-amd64), const EBADMSG = 92 #67998
-pkg syscall (openbsd-amd64), const ELAST = 95 #67998
-pkg syscall (openbsd-amd64), const ENOTRECOVERABLE = 93 #67998
-pkg syscall (openbsd-amd64), const ENOTRECOVERABLE Errno #67998
-pkg syscall (openbsd-amd64), const EOWNERDEAD = 94 #67998
-pkg syscall (openbsd-amd64), const EOWNERDEAD Errno #67998
-pkg syscall (openbsd-amd64), const EPROTO = 95 #67998
-pkg syscall (openbsd-amd64-cgo), const EBADMSG = 92 #67998
-pkg syscall (openbsd-amd64-cgo), const ELAST = 95 #67998
-pkg syscall (openbsd-amd64-cgo), const ENOTRECOVERABLE = 93 #67998
-pkg syscall (openbsd-amd64-cgo), const ENOTRECOVERABLE Errno #67998
-pkg syscall (openbsd-amd64-cgo), const EOWNERDEAD = 94 #67998
-pkg syscall (openbsd-amd64-cgo), const EOWNERDEAD Errno #67998
-pkg syscall (openbsd-amd64-cgo), const EPROTO = 95 #67998
-pkg syscall (windows-386), const WSAENOPROTOOPT = 10042 #62254
-pkg syscall (windows-386), const WSAENOPROTOOPT Errno #62254
-pkg syscall (windows-amd64), const WSAENOPROTOOPT = 10042 #62254
-pkg syscall (windows-amd64), const WSAENOPROTOOPT Errno #62254
-pkg syscall, const EBADMSG Errno #67998
-pkg syscall, const EPROTO Errno #67998
-pkg unicode/utf16, func RuneLen(int32) int #44940
-pkg unique, func Make[$0 comparable]($0) Handle[$0] #62483
-pkg unique, method (Handle[$0]) Value() $0 #62483
-pkg unique, type Handle[$0 comparable] struct #62483

api/go1.24.txt

@@ -1,223 +0,0 @@
-pkg bytes, func FieldsFuncSeq([]uint8, func(int32) bool) iter.Seq[[]uint8] #61901
-pkg bytes, func FieldsSeq([]uint8) iter.Seq[[]uint8] #61901
-pkg bytes, func Lines([]uint8) iter.Seq[[]uint8] #61901
-pkg bytes, func SplitAfterSeq([]uint8, []uint8) iter.Seq[[]uint8] #61901
-pkg bytes, func SplitSeq([]uint8, []uint8) iter.Seq[[]uint8] #61901
-pkg crypto/cipher, func NewCFBDecrypter //deprecated #69445
-pkg crypto/cipher, func NewCFBEncrypter //deprecated #69445
-pkg crypto/cipher, func NewGCMWithRandomNonce(Block) (AEAD, error) #69981
-pkg crypto/cipher, func NewOFB //deprecated #69445
-pkg crypto/fips140, func Enabled() bool #70123
-pkg crypto/hkdf, func Expand[$0 hash.Hash](func() $0, []uint8, string, int) ([]uint8, error) #61477
-pkg crypto/hkdf, func Extract[$0 hash.Hash](func() $0, []uint8, []uint8) ([]uint8, error) #61477
-pkg crypto/hkdf, func Key[$0 hash.Hash](func() $0, []uint8, []uint8, string, int) ([]uint8, error) #61477
-pkg crypto/mlkem, const CiphertextSize1024 = 1568 #70122
-pkg crypto/mlkem, const CiphertextSize1024 ideal-int #70122
-pkg crypto/mlkem, const CiphertextSize768 = 1088 #70122
-pkg crypto/mlkem, const CiphertextSize768 ideal-int #70122
-pkg crypto/mlkem, const EncapsulationKeySize1024 = 1568 #70122
-pkg crypto/mlkem, const EncapsulationKeySize1024 ideal-int #70122
-pkg crypto/mlkem, const EncapsulationKeySize768 = 1184 #70122
-pkg crypto/mlkem, const EncapsulationKeySize768 ideal-int #70122
-pkg crypto/mlkem, const SeedSize = 64 #70122
-pkg crypto/mlkem, const SeedSize ideal-int #70122
-pkg crypto/mlkem, const SharedKeySize = 32 #70122
-pkg crypto/mlkem, const SharedKeySize ideal-int #70122
-pkg crypto/mlkem, func GenerateKey1024() (*DecapsulationKey1024, error) #70122
-pkg crypto/mlkem, func GenerateKey768() (*DecapsulationKey768, error) #70122
-pkg crypto/mlkem, func NewDecapsulationKey1024([]uint8) (*DecapsulationKey1024, error) #70122
-pkg crypto/mlkem, func NewDecapsulationKey768([]uint8) (*DecapsulationKey768, error) #70122
-pkg crypto/mlkem, func NewEncapsulationKey1024([]uint8) (*EncapsulationKey1024, error) #70122
-pkg crypto/mlkem, func NewEncapsulationKey768([]uint8) (*EncapsulationKey768, error) #70122
-pkg crypto/mlkem, method (*DecapsulationKey1024) Bytes() []uint8 #70122
-pkg crypto/mlkem, method (*DecapsulationKey1024) Decapsulate([]uint8) ([]uint8, error) #70122
-pkg crypto/mlkem, method (*DecapsulationKey1024) EncapsulationKey() *EncapsulationKey1024 #70122
-pkg crypto/mlkem, method (*DecapsulationKey768) Bytes() []uint8 #70122
-pkg crypto/mlkem, method (*DecapsulationKey768) Decapsulate([]uint8) ([]uint8, error) #70122
-pkg crypto/mlkem, method (*DecapsulationKey768) EncapsulationKey() *EncapsulationKey768 #70122
-pkg crypto/mlkem, method (*EncapsulationKey1024) Bytes() []uint8 #70122
-pkg crypto/mlkem, method (*EncapsulationKey1024) Encapsulate() ([]uint8, []uint8) #70122
-pkg crypto/mlkem, method (*EncapsulationKey768) Bytes() []uint8 #70122
-pkg crypto/mlkem, method (*EncapsulationKey768) Encapsulate() ([]uint8, []uint8) #70122
-pkg crypto/mlkem, type DecapsulationKey1024 struct #70122
-pkg crypto/mlkem, type DecapsulationKey768 struct #70122
-pkg crypto/mlkem, type EncapsulationKey1024 struct #70122
-pkg crypto/mlkem, type EncapsulationKey768 struct #70122
-pkg crypto/pbkdf2, func Key[$0 hash.Hash](func() $0, string, []uint8, int, int) ([]uint8, error) #69488
-pkg crypto/rand, func Text() string #67057
-pkg crypto/sha3, func New224() *SHA3 #69982
-pkg crypto/sha3, func New256() *SHA3 #69982
-pkg crypto/sha3, func New384() *SHA3 #69982
-pkg crypto/sha3, func New512() *SHA3 #69982
-pkg crypto/sha3, func NewCSHAKE128([]uint8, []uint8) *SHAKE #69982
-pkg crypto/sha3, func NewCSHAKE256([]uint8, []uint8) *SHAKE #69982
-pkg crypto/sha3, func NewSHAKE128() *SHAKE #69982
-pkg crypto/sha3, func NewSHAKE256() *SHAKE #69982
-pkg crypto/sha3, func Sum224([]uint8) [28]uint8 #69982
-pkg crypto/sha3, func Sum256([]uint8) [32]uint8 #69982
-pkg crypto/sha3, func Sum384([]uint8) [48]uint8 #69982
-pkg crypto/sha3, func Sum512([]uint8) [64]uint8 #69982
-pkg crypto/sha3, func SumSHAKE128([]uint8, int) []uint8 #69982
-pkg crypto/sha3, func SumSHAKE256([]uint8, int) []uint8 #69982
-pkg crypto/sha3, method (*SHA3) AppendBinary([]uint8) ([]uint8, error) #69982
-pkg crypto/sha3, method (*SHA3) BlockSize() int #69982
-pkg crypto/sha3, method (*SHA3) MarshalBinary() ([]uint8, error) #69982
-pkg crypto/sha3, method (*SHA3) Reset() #69982
-pkg crypto/sha3, method (*SHA3) Size() int #69982
-pkg crypto/sha3, method (*SHA3) Sum([]uint8) []uint8 #69982
-pkg crypto/sha3, method (*SHA3) UnmarshalBinary([]uint8) error #69982
-pkg crypto/sha3, method (*SHA3) Write([]uint8) (int, error) #69982
-pkg crypto/sha3, method (*SHAKE) AppendBinary([]uint8) ([]uint8, error) #69982
-pkg crypto/sha3, method (*SHAKE) BlockSize() int #69982
-pkg crypto/sha3, method (*SHAKE) MarshalBinary() ([]uint8, error) #69982
-pkg crypto/sha3, method (*SHAKE) Read([]uint8) (int, error) #69982
-pkg crypto/sha3, method (*SHAKE) Reset() #69982
-pkg crypto/sha3, method (*SHAKE) UnmarshalBinary([]uint8) error #69982
-pkg crypto/sha3, method (*SHAKE) Write([]uint8) (int, error) #69982
-pkg crypto/sha3, type SHA3 struct #69982
-pkg crypto/sha3, type SHAKE struct #69982
-pkg crypto/subtle, func WithDataIndependentTiming(func()) #66450
-pkg crypto/tls, const X25519MLKEM768 = 4588 #69985
-pkg crypto/tls, const X25519MLKEM768 CurveID #69985
-pkg crypto/tls, type ClientHelloInfo struct, Extensions []uint16 #32936
-pkg crypto/tls, type Config struct, EncryptedClientHelloKeys []EncryptedClientHelloKey #68500
-pkg crypto/tls, type EncryptedClientHelloKey struct #68500
-pkg crypto/tls, type EncryptedClientHelloKey struct, Config []uint8 #68500
-pkg crypto/tls, type EncryptedClientHelloKey struct, PrivateKey []uint8 #68500
-pkg crypto/tls, type EncryptedClientHelloKey struct, SendAsRetry bool #68500
-pkg crypto/x509, const NoValidChains = 10 #68484
-pkg crypto/x509, const NoValidChains InvalidReason #68484
-pkg crypto/x509, method (OID) AppendBinary([]uint8) ([]uint8, error) #62384
-pkg crypto/x509, method (OID) AppendText([]uint8) ([]uint8, error) #62384
-pkg crypto/x509, type Certificate struct, InhibitAnyPolicy int #68484
-pkg crypto/x509, type Certificate struct, InhibitAnyPolicyZero bool #68484
-pkg crypto/x509, type Certificate struct, InhibitPolicyMapping int #68484
-pkg crypto/x509, type Certificate struct, InhibitPolicyMappingZero bool #68484
-pkg crypto/x509, type Certificate struct, PolicyMappings []PolicyMapping #68484
-pkg crypto/x509, type Certificate struct, RequireExplicitPolicy int #68484
-pkg crypto/x509, type Certificate struct, RequireExplicitPolicyZero bool #68484
-pkg crypto/x509, type PolicyMapping struct #68484
-pkg crypto/x509, type PolicyMapping struct, IssuerDomainPolicy OID #68484
-pkg crypto/x509, type PolicyMapping struct, SubjectDomainPolicy OID #68484
-pkg crypto/x509, type VerifyOptions struct, CertificatePolicies []OID #68484
-pkg debug/elf, const VER_FLG_BASE = 1 #63952
-pkg debug/elf, const VER_FLG_BASE DynamicVersionFlag #63952
-pkg debug/elf, const VER_FLG_INFO = 4 #63952
-pkg debug/elf, const VER_FLG_INFO DynamicVersionFlag #63952
-pkg debug/elf, const VER_FLG_WEAK = 2 #63952
-pkg debug/elf, const VER_FLG_WEAK DynamicVersionFlag #63952
-pkg debug/elf, method (*File) DynamicVersionNeeds() ([]DynamicVersionNeed, error) #63952
-pkg debug/elf, method (*File) DynamicVersions() ([]DynamicVersion, error) #63952
-pkg debug/elf, type DynamicVersion struct #63952
-pkg debug/elf, type DynamicVersion struct, Deps []string #63952
-pkg debug/elf, type DynamicVersion struct, Flags DynamicVersionFlag #63952
-pkg debug/elf, type DynamicVersion struct, Name string #63952
-pkg debug/elf, type DynamicVersion struct, Index uint16 #63952
-pkg debug/elf, type DynamicVersionDep struct #63952
-pkg debug/elf, type DynamicVersionDep struct, Dep string #63952
-pkg debug/elf, type DynamicVersionDep struct, Flags DynamicVersionFlag #63952
-pkg debug/elf, type DynamicVersionDep struct, Index uint16 #63952
-pkg debug/elf, type DynamicVersionFlag uint16 #63952
-pkg debug/elf, type DynamicVersionNeed struct #63952
-pkg debug/elf, type DynamicVersionNeed struct, Name string #63952
-pkg debug/elf, type DynamicVersionNeed struct, Needs []DynamicVersionDep #63952
-pkg debug/elf, type Symbol struct, HasVersion bool #63952
-pkg debug/elf, type Symbol struct, VersionIndex VersionIndex #63952
-pkg debug/elf, method (VersionIndex) Index() uint16 #63952
-pkg debug/elf, method (VersionIndex) IsHidden() bool #63952
-pkg debug/elf, type VersionIndex uint16 #63952
-pkg encoding, type BinaryAppender interface { AppendBinary } #62384
-pkg encoding, type BinaryAppender interface, AppendBinary([]uint8) ([]uint8, error) #62384
-pkg encoding, type TextAppender interface { AppendText } #62384
-pkg encoding, type TextAppender interface, AppendText([]uint8) ([]uint8, error) #62384
-pkg go/types, method (*Interface) EmbeddedTypes() iter.Seq[Type] #66626
-pkg go/types, method (*Interface) ExplicitMethods() iter.Seq[*Func] #66626
-pkg go/types, method (*Interface) Methods() iter.Seq[*Func] #66626
-pkg go/types, method (*MethodSet) Methods() iter.Seq[*Selection] #66626
-pkg go/types, method (*Named) Methods() iter.Seq[*Func] #66626
-pkg go/types, method (*Scope) Children() iter.Seq[*Scope] #66626
-pkg go/types, method (*Struct) Fields() iter.Seq[*Var] #66626
-pkg go/types, method (*Tuple) Variables() iter.Seq[*Var] #66626
-pkg go/types, method (*TypeList) Types() iter.Seq[Type] #66626
-pkg go/types, method (*TypeParamList) TypeParams() iter.Seq[*TypeParam] #66626
-pkg go/types, method (*Union) Terms() iter.Seq[*Term] #66626
-pkg hash/maphash, func Comparable[$0 comparable](Seed, $0) uint64 #54670
-pkg hash/maphash, func WriteComparable[$0 comparable](*Hash, $0) #54670
-pkg log/slog, method (*LevelVar) AppendText([]uint8) ([]uint8, error) #62384
-pkg log/slog, method (Level) AppendText([]uint8) ([]uint8, error) #62384
-pkg log/slog, var DiscardHandler Handler #62005
-pkg math/big, method (*Float) AppendText([]uint8) ([]uint8, error) #62384
-pkg math/big, method (*Int) AppendText([]uint8) ([]uint8, error) #62384
-pkg math/big, method (*Rat) AppendText([]uint8) ([]uint8, error) #62384
-pkg math/rand/v2, method (*ChaCha8) AppendBinary([]uint8) ([]uint8, error) #62384
-pkg math/rand/v2, method (*PCG) AppendBinary([]uint8) ([]uint8, error) #62384
-pkg net, method (IP) AppendText([]uint8) ([]uint8, error) #62384
-pkg net/http, method (*Protocols) SetHTTP1(bool) #67814
-pkg net/http, method (*Protocols) SetHTTP2(bool) #67814
-pkg net/http, method (*Protocols) SetUnencryptedHTTP2(bool) #67816
-pkg net/http, method (Protocols) HTTP1() bool #67814
-pkg net/http, method (Protocols) HTTP2() bool #67814
-pkg net/http, method (Protocols) String() string #67814
-pkg net/http, method (Protocols) UnencryptedHTTP2() bool #67816
-pkg net/http, type HTTP2Config struct #67813
-pkg net/http, type HTTP2Config struct, CountError func(string) #67813
-pkg net/http, type HTTP2Config struct, MaxConcurrentStreams int #67813
-pkg net/http, type HTTP2Config struct, MaxDecoderHeaderTableSize int #67813
-pkg net/http, type HTTP2Config struct, MaxEncoderHeaderTableSize int #67813
-pkg net/http, type HTTP2Config struct, MaxReadFrameSize int #67813
-pkg net/http, type HTTP2Config struct, MaxReceiveBufferPerConnection int #67813
-pkg net/http, type HTTP2Config struct, MaxReceiveBufferPerStream int #67813
-pkg net/http, type HTTP2Config struct, PermitProhibitedCipherSuites bool #67813
-pkg net/http, type HTTP2Config struct, PingTimeout time.Duration #67813
-pkg net/http, type HTTP2Config struct, SendPingTimeout time.Duration #67813
-pkg net/http, type HTTP2Config struct, WriteByteTimeout time.Duration #67813
-pkg net/http, type Protocols struct #67814
-pkg net/http, type Server struct, HTTP2 *HTTP2Config #67813
-pkg net/http, type Server struct, Protocols *Protocols #67814
-pkg net/http, type Transport struct, HTTP2 *HTTP2Config #67813
-pkg net/http, type Transport struct, Protocols *Protocols #67814
-pkg net/netip, method (Addr) AppendBinary([]uint8) ([]uint8, error) #62384
-pkg net/netip, method (Addr) AppendText([]uint8) ([]uint8, error) #62384
-pkg net/netip, method (AddrPort) AppendBinary([]uint8) ([]uint8, error) #62384
-pkg net/netip, method (AddrPort) AppendText([]uint8) ([]uint8, error) #62384
-pkg net/netip, method (Prefix) AppendBinary([]uint8) ([]uint8, error) #62384
-pkg net/netip, method (Prefix) AppendText([]uint8) ([]uint8, error) #62384
-pkg net/url, method (*URL) AppendBinary([]uint8) ([]uint8, error) #62384
-pkg os, func OpenInRoot(string, string) (*File, error) #67002
-pkg os, func OpenRoot(string) (*Root, error) #67002
-pkg os, method (*Root) Close() error #67002
-pkg os, method (*Root) Create(string) (*File, error) #67002
-pkg os, method (*Root) FS() fs.FS #67002
-pkg os, method (*Root) Lstat(string) (fs.FileInfo, error) #67002
-pkg os, method (*Root) Mkdir(string, fs.FileMode) error #67002
-pkg os, method (*Root) Name() string #67002
-pkg os, method (*Root) Open(string) (*File, error) #67002
-pkg os, method (*Root) OpenFile(string, int, fs.FileMode) (*File, error) #67002
-pkg os, method (*Root) OpenRoot(string) (*Root, error) #67002
-pkg os, method (*Root) Remove(string) error #67002
-pkg os, method (*Root) Stat(string) (fs.FileInfo, error) #67002
-pkg os, type Root struct #67002
-pkg regexp, method (*Regexp) AppendText([]uint8) ([]uint8, error) #62384
-pkg runtime, func AddCleanup[$0 interface{}, $1 interface{}](*$0, func($1), $1) Cleanup #67535
-pkg runtime, func GOROOT //deprecated #51473
-pkg runtime, method (Cleanup) Stop() #67535
-pkg runtime, type Cleanup struct #67535
-pkg strings, func FieldsFuncSeq(string, func(int32) bool) iter.Seq[string] #61901
-pkg strings, func FieldsSeq(string) iter.Seq[string] #61901
-pkg strings, func Lines(string) iter.Seq[string] #61901
-pkg strings, func SplitAfterSeq(string, string) iter.Seq[string] #61901
-pkg strings, func SplitSeq(string, string) iter.Seq[string] #61901
-pkg testing, method (*B) Chdir(string) #62516
-pkg testing, method (*B) Context() context.Context #36532
-pkg testing, method (*B) Loop() bool #61515
-pkg testing, method (*F) Chdir(string) #62516
-pkg testing, method (*F) Context() context.Context #36532
-pkg testing, method (*T) Chdir(string) #62516
-pkg testing, method (*T) Context() context.Context #36532
-pkg testing, type TB interface, Chdir(string) #62516
-pkg testing, type TB interface, Context() context.Context #36532
-pkg time, method (Time) AppendBinary([]uint8) ([]uint8, error) #62384
-pkg time, method (Time) AppendText([]uint8) ([]uint8, error) #62384
-pkg weak, func Make[$0 interface{}](*$0) Pointer[$0] #67552
-pkg weak, method (Pointer[$0]) Value() *$0 #67552
-pkg weak, type Pointer[$0 interface{}] struct #67552

api/go1.25.txt

@@ -1,111 +0,0 @@
-pkg crypto, func SignMessage(Signer, io.Reader, []uint8, SignerOpts) ([]uint8, error) #63405
-pkg crypto, type MessageSigner interface { Public, Sign, SignMessage } #63405
-pkg crypto, type MessageSigner interface, Public() PublicKey #63405
-pkg crypto, type MessageSigner interface, Sign(io.Reader, []uint8, SignerOpts) ([]uint8, error) #63405
-pkg crypto, type MessageSigner interface, SignMessage(io.Reader, []uint8, SignerOpts) ([]uint8, error) #63405
-pkg crypto/ecdsa, func ParseRawPrivateKey(elliptic.Curve, []uint8) (*PrivateKey, error) #63963
-pkg crypto/ecdsa, func ParseUncompressedPublicKey(elliptic.Curve, []uint8) (*PublicKey, error) #63963
-pkg crypto/ecdsa, method (*PrivateKey) Bytes() ([]uint8, error) #63963
-pkg crypto/ecdsa, method (*PublicKey) Bytes() ([]uint8, error) #63963
-pkg crypto/sha3, method (*SHA3) Clone() (hash.Cloner, error) #69521
-pkg crypto/tls, type Config struct, GetEncryptedClientHelloKeys func(*ClientHelloInfo) ([]EncryptedClientHelloKey, error) #71920
-pkg crypto/tls, type ConnectionState struct, CurveID CurveID #67516
-pkg debug/elf, const PT_RISCV_ATTRIBUTES = 1879048195 #72843
-pkg debug/elf, const PT_RISCV_ATTRIBUTES ProgType #72843
-pkg debug/elf, const SHT_RISCV_ATTRIBUTES = 1879048195 #72843
-pkg debug/elf, const SHT_RISCV_ATTRIBUTES SectionType #72843
-pkg go/ast, const FilterFuncDuplicates //deprecated #73088
-pkg go/ast, const FilterImportDuplicates //deprecated #73088
-pkg go/ast, const FilterUnassociatedComments //deprecated #73088
-pkg go/ast, func FilterPackage //deprecated #73088
-pkg go/ast, func MergePackageFiles //deprecated #73088
-pkg go/ast, func PackageExports //deprecated #73088
-pkg go/ast, func PreorderStack(Node, []Node, func(Node, []Node) bool) #73319
-pkg go/ast, type MergeMode //deprecated #73088
-pkg go/parser, func ParseDir //deprecated #71122
-pkg go/token, method (*FileSet) AddExistingFiles(...*File) #73205
-pkg go/types, const FieldVar = 6 #70250
-pkg go/types, const FieldVar VarKind #70250
-pkg go/types, const LocalVar = 2 #70250
-pkg go/types, const LocalVar VarKind #70250
-pkg go/types, const PackageVar = 1 #70250
-pkg go/types, const PackageVar VarKind #70250
-pkg go/types, const ParamVar = 4 #70250
-pkg go/types, const ParamVar VarKind #70250
-pkg go/types, const RecvVar = 3 #70250
-pkg go/types, const RecvVar VarKind #70250
-pkg go/types, const ResultVar = 5 #70250
-pkg go/types, const ResultVar VarKind #70250
-pkg go/types, func LookupSelection(Type, bool, *Package, string) (Selection, bool) #70737
-pkg go/types, method (*Var) Kind() VarKind #70250
-pkg go/types, method (*Var) SetKind(VarKind) #70250
-pkg go/types, method (VarKind) String() string #70250
-pkg go/types, type VarKind uint8 #70250
-pkg hash, type Cloner interface { BlockSize, Clone, Reset, Size, Sum, Write } #69521
-pkg hash, type Cloner interface, BlockSize() int #69521
-pkg hash, type Cloner interface, Clone() (Cloner, error) #69521
-pkg hash, type Cloner interface, Reset() #69521
-pkg hash, type Cloner interface, Size() int #69521
-pkg hash, type Cloner interface, Sum([]uint8) []uint8 #69521
-pkg hash, type Cloner interface, Write([]uint8) (int, error) #69521
-pkg hash, type XOF interface { BlockSize, Read, Reset, Write } #69518
-pkg hash, type XOF interface, BlockSize() int #69518
-pkg hash, type XOF interface, Read([]uint8) (int, error) #69518
-pkg hash, type XOF interface, Reset() #69518
-pkg hash, type XOF interface, Write([]uint8) (int, error) #69518
-pkg hash/maphash, method (*Hash) Clone() (hash.Cloner, error) #69521
-pkg io/fs, func Lstat(FS, string) (FileInfo, error) #49580
-pkg io/fs, func ReadLink(FS, string) (string, error) #49580
-pkg io/fs, type ReadLinkFS interface { Lstat, Open, ReadLink } #49580
-pkg io/fs, type ReadLinkFS interface, Lstat(string) (FileInfo, error) #49580
-pkg io/fs, type ReadLinkFS interface, Open(string) (File, error) #49580
-pkg io/fs, type ReadLinkFS interface, ReadLink(string) (string, error) #49580
-pkg log/slog, func GroupAttrs(string, ...Attr) Attr #66365
-pkg log/slog, method (Record) Source() *Source #70280
-pkg mime/multipart, func FileContentDisposition(string, string) string #46771
-pkg net/http, func NewCrossOriginProtection() *CrossOriginProtection #73626
-pkg net/http, method (*CrossOriginProtection) AddInsecureBypassPattern(string) #73626
-pkg net/http, method (*CrossOriginProtection) AddTrustedOrigin(string) error #73626
-pkg net/http, method (*CrossOriginProtection) Check(*Request) error #73626
-pkg net/http, method (*CrossOriginProtection) Handler(Handler) Handler #73626
-pkg net/http, method (*CrossOriginProtection) SetDenyHandler(Handler) #73626
-pkg net/http, type CrossOriginProtection struct #73626
-pkg os, method (*Root) Chmod(string, fs.FileMode) error #67002
-pkg os, method (*Root) Chown(string, int, int) error #67002
-pkg os, method (*Root) Chtimes(string, time.Time, time.Time) error #67002
-pkg os, method (*Root) Lchown(string, int, int) error #67002
-pkg os, method (*Root) Link(string, string) error #67002
-pkg os, method (*Root) MkdirAll(string, fs.FileMode) error #67002
-pkg os, method (*Root) ReadFile(string) ([]uint8, error) #73126
-pkg os, method (*Root) Readlink(string) (string, error) #67002
-pkg os, method (*Root) RemoveAll(string) error #67002
-pkg os, method (*Root) Rename(string, string) error #67002
-pkg os, method (*Root) Symlink(string, string) error #67002
-pkg os, method (*Root) WriteFile(string, []uint8, fs.FileMode) error #73126
-pkg reflect, func TypeAssert[$0 interface{}](Value) ($0, bool) #62121
-pkg runtime, func SetDefaultGOMAXPROCS() #73193
-pkg runtime/trace, func NewFlightRecorder(FlightRecorderConfig) *FlightRecorder #63185
-pkg runtime/trace, method (*FlightRecorder) Enabled() bool #63185
-pkg runtime/trace, method (*FlightRecorder) Start() error #63185
-pkg runtime/trace, method (*FlightRecorder) Stop() #63185
-pkg runtime/trace, method (*FlightRecorder) WriteTo(io.Writer) (int64, error) #63185
-pkg runtime/trace, type FlightRecorder struct #63185
-pkg runtime/trace, type FlightRecorderConfig struct #63185
-pkg runtime/trace, type FlightRecorderConfig struct, MaxBytes uint64 #63185
-pkg runtime/trace, type FlightRecorderConfig struct, MinAge time.Duration #63185
-pkg sync, method (*WaitGroup) Go(func()) #63796
-pkg testing, method (*B) Attr(string, string) #43936
-pkg testing, method (*B) Output() io.Writer #59928
-pkg testing, method (*F) Attr(string, string) #43936
-pkg testing, method (*F) Output() io.Writer #59928
-pkg testing, method (*T) Attr(string, string) #43936
-pkg testing, method (*T) Output() io.Writer #59928
-pkg testing, type TB interface, Attr(string, string) #43936
-pkg testing, type TB interface, Output() io.Writer #59928
-pkg testing/fstest, method (MapFS) Lstat(string) (fs.FileInfo, error) #49580
-pkg testing/fstest, method (MapFS) ReadLink(string) (string, error) #49580
-pkg testing/synctest, func Test(*testing.T, func(*testing.T)) #67434
-pkg testing/synctest, func Wait() #67434
-pkg unicode, var CategoryAliases map[string]string #70780
-pkg unicode, var Cn *RangeTable #70780
-pkg unicode, var LC *RangeTable #70780

api/go1.26.txt

@@ -1,180 +0,0 @@
-pkg bytes, method (*Buffer) Peek(int) ([]uint8, error) #73794
-pkg crypto, type Decapsulator interface { Decapsulate, Encapsulator } #75300
-pkg crypto, type Decapsulator interface, Decapsulate([]uint8) ([]uint8, error) #75300
-pkg crypto, type Decapsulator interface, Encapsulator() Encapsulator #75300
-pkg crypto, type Encapsulator interface { Bytes, Encapsulate } #75300
-pkg crypto, type Encapsulator interface, Bytes() []uint8 #75300
-pkg crypto, type Encapsulator interface, Encapsulate() ([]uint8, []uint8) #75300
-pkg crypto/ecdh, type KeyExchanger interface { Curve, ECDH, PublicKey } #75300
-pkg crypto/ecdh, type KeyExchanger interface, Curve() Curve #75300
-pkg crypto/ecdh, type KeyExchanger interface, ECDH(*PublicKey) ([]uint8, error) #75300
-pkg crypto/ecdh, type KeyExchanger interface, PublicKey() *PublicKey #75300
-pkg crypto/ecdsa, type PrivateKey struct, D //deprecated #63963
-pkg crypto/ecdsa, type PublicKey struct, X //deprecated #63963
-pkg crypto/ecdsa, type PublicKey struct, Y //deprecated #63963
-pkg crypto/fips140, func Enforced() bool #74630
-pkg crypto/fips140, func Version() string #75301
-pkg crypto/fips140, func WithoutEnforcement(func()) #74630
-pkg crypto/hpke, func AES128GCM() AEAD #75300
-pkg crypto/hpke, func AES256GCM() AEAD #75300
-pkg crypto/hpke, func ChaCha20Poly1305() AEAD #75300
-pkg crypto/hpke, func DHKEM(ecdh.Curve) KEM #75300
-pkg crypto/hpke, func ExportOnly() AEAD #75300
-pkg crypto/hpke, func HKDFSHA256() KDF #75300
-pkg crypto/hpke, func HKDFSHA384() KDF #75300
-pkg crypto/hpke, func HKDFSHA512() KDF #75300
-pkg crypto/hpke, func MLKEM1024() KEM #75300
-pkg crypto/hpke, func MLKEM1024P384() KEM #75300
-pkg crypto/hpke, func MLKEM768() KEM #75300
-pkg crypto/hpke, func MLKEM768P256() KEM #75300
-pkg crypto/hpke, func MLKEM768X25519() KEM #75300
-pkg crypto/hpke, func NewAEAD(uint16) (AEAD, error) #75300
-pkg crypto/hpke, func NewDHKEMPrivateKey(ecdh.KeyExchanger) (PrivateKey, error) #75300
-pkg crypto/hpke, func NewDHKEMPublicKey(*ecdh.PublicKey) (PublicKey, error) #75300
-pkg crypto/hpke, func NewHybridPrivateKey(crypto.Decapsulator, ecdh.KeyExchanger) (PrivateKey, error) #75300
-pkg crypto/hpke, func NewHybridPublicKey(crypto.Encapsulator, *ecdh.PublicKey) (PublicKey, error) #75300
-pkg crypto/hpke, func NewKDF(uint16) (KDF, error) #75300
-pkg crypto/hpke, func NewKEM(uint16) (KEM, error) #75300
-pkg crypto/hpke, func NewMLKEMPrivateKey(crypto.Decapsulator) (PrivateKey, error) #75300
-pkg crypto/hpke, func NewMLKEMPublicKey(crypto.Encapsulator) (PublicKey, error) #75300
-pkg crypto/hpke, func NewRecipient([]uint8, PrivateKey, KDF, AEAD, []uint8) (*Recipient, error) #75300
-pkg crypto/hpke, func NewSender(PublicKey, KDF, AEAD, []uint8) ([]uint8, *Sender, error) #75300
-pkg crypto/hpke, func Open(PrivateKey, KDF, AEAD, []uint8, []uint8) ([]uint8, error) #75300
-pkg crypto/hpke, func SHAKE128() KDF #75300
-pkg crypto/hpke, func SHAKE256() KDF #75300
-pkg crypto/hpke, func Seal(PublicKey, KDF, AEAD, []uint8, []uint8) ([]uint8, error) #75300
-pkg crypto/hpke, method (*Recipient) Export(string, int) ([]uint8, error) #75300
-pkg crypto/hpke, method (*Recipient) Open([]uint8, []uint8) ([]uint8, error) #75300
-pkg crypto/hpke, method (*Sender) Export(string, int) ([]uint8, error) #75300
-pkg crypto/hpke, method (*Sender) Seal([]uint8, []uint8) ([]uint8, error) #75300
-pkg crypto/hpke, type AEAD interface, ID() uint16 #75300
-pkg crypto/hpke, type AEAD interface, unexported methods #75300
-pkg crypto/hpke, type KDF interface, ID() uint16 #75300
-pkg crypto/hpke, type KDF interface, unexported methods #75300
-pkg crypto/hpke, type KEM interface, DeriveKeyPair([]uint8) (PrivateKey, error) #75300
-pkg crypto/hpke, type KEM interface, GenerateKey() (PrivateKey, error) #75300
-pkg crypto/hpke, type KEM interface, ID() uint16 #75300
-pkg crypto/hpke, type KEM interface, NewPrivateKey([]uint8) (PrivateKey, error) #75300
-pkg crypto/hpke, type KEM interface, NewPublicKey([]uint8) (PublicKey, error) #75300
-pkg crypto/hpke, type KEM interface, unexported methods #75300
-pkg crypto/hpke, type PrivateKey interface, Bytes() ([]uint8, error) #75300
-pkg crypto/hpke, type PrivateKey interface, KEM() KEM #75300
-pkg crypto/hpke, type PrivateKey interface, PublicKey() PublicKey #75300
-pkg crypto/hpke, type PrivateKey interface, unexported methods #75300
-pkg crypto/hpke, type PublicKey interface, Bytes() []uint8 #75300
-pkg crypto/hpke, type PublicKey interface, KEM() KEM #75300
-pkg crypto/hpke, type PublicKey interface, unexported methods #75300
-pkg crypto/hpke, type Recipient struct #75300
-pkg crypto/hpke, type Sender struct #75300
-pkg crypto/mlkem, method (*DecapsulationKey1024) Encapsulator() crypto.Encapsulator #75300
-pkg crypto/mlkem, method (*DecapsulationKey768) Encapsulator() crypto.Encapsulator #75300
-pkg crypto/mlkem/mlkemtest, func Encapsulate1024(*mlkem.EncapsulationKey1024, []uint8) ([]uint8, []uint8, error) #73627
-pkg crypto/mlkem/mlkemtest, func Encapsulate768(*mlkem.EncapsulationKey768, []uint8) ([]uint8, []uint8, error) #73627
-pkg crypto/rsa, func DecryptPKCS1v15 //deprecated #75302
-pkg crypto/rsa, func DecryptPKCS1v15SessionKey //deprecated #75302
-pkg crypto/rsa, func EncryptOAEPWithOptions(io.Reader, *PublicKey, []uint8, *OAEPOptions) ([]uint8, error) #65716
-pkg crypto/rsa, func EncryptPKCS1v15 //deprecated #75302
-pkg crypto/rsa, type PKCS1v15DecryptOptions //deprecated #75302
-pkg crypto/tls, const QUICErrorEvent = 10 #75108
-pkg crypto/tls, const QUICErrorEvent QUICEventKind #75108
-pkg crypto/tls, const SecP256r1MLKEM768 = 4587 #71206
-pkg crypto/tls, const SecP256r1MLKEM768 CurveID #71206
-pkg crypto/tls, const SecP384r1MLKEM1024 = 4589 #71206
-pkg crypto/tls, const SecP384r1MLKEM1024 CurveID #71206
-pkg crypto/tls, type ClientHelloInfo struct, HelloRetryRequest bool #74425
-pkg crypto/tls, type ConnectionState struct, HelloRetryRequest bool #74425
-pkg crypto/tls, type QUICEvent struct, Err error #75108
-pkg crypto/x509, func OIDFromASN1OID(asn1.ObjectIdentifier) (OID, error) #75325
-pkg crypto/x509, method (ExtKeyUsage) OID() OID #75325
-pkg crypto/x509, method (ExtKeyUsage) String() string #56866
-pkg crypto/x509, method (KeyUsage) String() string #56866
-pkg debug/elf, const R_LARCH_CALL36 = 110 #75562
-pkg debug/elf, const R_LARCH_CALL36 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC32 = 13 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC32 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64 = 14 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_HI12 = 118 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_HI12 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_LO20 = 117 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_LO20 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_PC_HI12 = 114 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_PC_HI12 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_PC_LO20 = 113 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_PC_LO20 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_CALL = 120 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_CALL R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_HI20 = 115 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_HI20 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_LD = 119 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_LD R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_LO12 = 116 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_LO12 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_PCREL20_S2 = 126 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_PCREL20_S2 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_PC_HI20 = 111 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_PC_HI20 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_PC_LO12 = 112 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_PC_LO12 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_GD_PCREL20_S2 = 125 #75562
-pkg debug/elf, const R_LARCH_TLS_GD_PCREL20_S2 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_LD_PCREL20_S2 = 124 #75562
-pkg debug/elf, const R_LARCH_TLS_LD_PCREL20_S2 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_LE_ADD_R = 122 #75562
-pkg debug/elf, const R_LARCH_TLS_LE_ADD_R R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_LE_HI20_R = 121 #75562
-pkg debug/elf, const R_LARCH_TLS_LE_HI20_R R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_LE_LO12_R = 123 #75562
-pkg debug/elf, const R_LARCH_TLS_LE_LO12_R R_LARCH #75562
-pkg errors, func AsType[$0 error](error) ($0, bool) #51945
-pkg go/ast, func ParseDirective(token.Pos, string) (Directive, bool) #68021
-pkg go/ast, method (*Directive) End() token.Pos #68021
-pkg go/ast, method (*Directive) ParseArgs() ([]DirectiveArg, error) #68021
-pkg go/ast, method (*Directive) Pos() token.Pos #68021
-pkg go/ast, type BasicLit struct, ValueEnd token.Pos #76031
-pkg go/ast, type Directive struct #68021
-pkg go/ast, type Directive struct, Args string #68021
-pkg go/ast, type Directive struct, ArgsPos token.Pos #68021
-pkg go/ast, type Directive struct, Name string #68021
-pkg go/ast, type Directive struct, Slash token.Pos #68021
-pkg go/ast, type Directive struct, Tool string #68021
-pkg go/ast, type DirectiveArg struct #68021
-pkg go/ast, type DirectiveArg struct, Arg string #68021
-pkg go/ast, type DirectiveArg struct, Pos token.Pos #68021
-pkg go/token, method (*File) End() Pos #75849
-pkg log/slog, func NewMultiHandler(...Handler) *MultiHandler #65954
-pkg log/slog, method (*MultiHandler) Enabled(context.Context, Level) bool #65954
-pkg log/slog, method (*MultiHandler) Handle(context.Context, Record) error #65954
-pkg log/slog, method (*MultiHandler) WithAttrs([]Attr) Handler #65954
-pkg log/slog, method (*MultiHandler) WithGroup(string) Handler #65954
-pkg log/slog, type MultiHandler struct #65954
-pkg net, method (*Dialer) DialIP(context.Context, string, netip.Addr, netip.Addr) (*IPConn, error) #49097
-pkg net, method (*Dialer) DialTCP(context.Context, string, netip.AddrPort, netip.AddrPort) (*TCPConn, error) #49097
-pkg net, method (*Dialer) DialUDP(context.Context, string, netip.AddrPort, netip.AddrPort) (*UDPConn, error) #49097
-pkg net, method (*Dialer) DialUnix(context.Context, string, *UnixAddr, *UnixAddr) (*UnixConn, error) #49097
-pkg net/http, method (*ClientConn) Available() int #75772
-pkg net/http, method (*ClientConn) Close() error #75772
-pkg net/http, method (*ClientConn) Err() error #75772
-pkg net/http, method (*ClientConn) InFlight() int #75772
-pkg net/http, method (*ClientConn) Release() #75772
-pkg net/http, method (*ClientConn) Reserve() error #75772
-pkg net/http, method (*ClientConn) RoundTrip(*Request) (*Response, error) #75772
-pkg net/http, method (*ClientConn) SetStateHook(func(*ClientConn)) #75772
-pkg net/http, method (*Transport) NewClientConn(context.Context, string, string) (*ClientConn, error) #75772
-pkg net/http, type ClientConn struct #75772
-pkg net/http, type HTTP2Config struct, StrictMaxConcurrentRequests bool #67813
-pkg net/http/httputil, type ReverseProxy struct, Director //deprecated #73161
-pkg net/netip, method (Prefix) Compare(Prefix) int #61642
-pkg os, method (*Process) WithHandle(func(uintptr)) error #70352
-pkg os, var ErrNoHandle error #70352
-pkg reflect, method (Value) Fields() iter.Seq2[StructField, Value] #66631
-pkg reflect, method (Value) Methods() iter.Seq2[Method, Value] #66631
-pkg reflect, type Type interface, Fields() iter.Seq[StructField] #66631
-pkg reflect, type Type interface, Ins() iter.Seq[Type] #66631
-pkg reflect, type Type interface, Methods() iter.Seq[Method] #66631
-pkg reflect, type Type interface, Outs() iter.Seq[Type] #66631
-pkg testing, method (*B) ArtifactDir() string #71287
-pkg testing, method (*F) ArtifactDir() string #71287
-pkg testing, method (*T) ArtifactDir() string #71287
-pkg testing, type TB interface, ArtifactDir() string #71287
-pkg testing/cryptotest, func SetGlobalRandom(*testing.T, uint64) #70942

api/next/30715.txt

@@ -0,0 +1,3 @@
+pkg net/http, type MaxBytesError struct #30715
+pkg net/http, type MaxBytesError struct, Limit int64 #30715
+pkg net/http, method (*MaxBytesError) Error() string #30715

api/next/35044.txt

@@ -0,0 +1 @@
+pkg crypto/x509, method (*CertPool) Clone() *CertPool #35044

api/next/42710.txt

@@ -0,0 +1,2 @@
+pkg hash/maphash, func Bytes(Seed, []uint8) uint64 #42710
+pkg hash/maphash, func String(Seed, string) uint64 #42710

api/next/45628.txt

@@ -0,0 +1 @@
+pkg encoding/xml, method (*Decoder) InputPos() (int, int) #45628

api/next/45754.txt

@@ -0,0 +1,2 @@
+pkg flag, func TextVar(encoding.TextUnmarshaler, string, encoding.TextMarshaler, string) #45754
+pkg flag, method (*FlagSet) TextVar(encoding.TextUnmarshaler, string, encoding.TextMarshaler, string) #45754

api/next/46057.txt

@@ -0,0 +1 @@
+pkg crypto/x509, method (*CertPool) Equal(*CertPool) bool #46057

api/next/46059.txt

@@ -0,0 +1,2 @@
+pkg net/url, type URL struct, OmitHost bool #46059
+

api/next/46121.txt

@@ -0,0 +1,2 @@
+pkg html/template, method (*Template) Funcs(template.FuncMap) *Template #46121
+pkg html/template, type FuncMap = template.FuncMap #46121

api/next/46229.txt

@@ -0,0 +1,105 @@
+pkg debug/elf, const EM_LOONGARCH = 258 #46229
+pkg debug/elf, const EM_LOONGARCH Machine #46229
+pkg debug/elf, const R_LARCH_32 = 1 #46229
+pkg debug/elf, const R_LARCH_32 R_LARCH #46229
+pkg debug/elf, const R_LARCH_64 = 2 #46229
+pkg debug/elf, const R_LARCH_64 R_LARCH #46229
+pkg debug/elf, const R_LARCH_ADD16 = 48 #46229
+pkg debug/elf, const R_LARCH_ADD16 R_LARCH #46229
+pkg debug/elf, const R_LARCH_ADD24 = 49 #46229
+pkg debug/elf, const R_LARCH_ADD24 R_LARCH #46229
+pkg debug/elf, const R_LARCH_ADD32 = 50 #46229
+pkg debug/elf, const R_LARCH_ADD32 R_LARCH #46229
+pkg debug/elf, const R_LARCH_ADD64 = 51 #46229
+pkg debug/elf, const R_LARCH_ADD64 R_LARCH #46229
+pkg debug/elf, const R_LARCH_ADD8 = 47 #46229
+pkg debug/elf, const R_LARCH_ADD8 R_LARCH #46229
+pkg debug/elf, const R_LARCH_COPY = 4 #46229
+pkg debug/elf, const R_LARCH_COPY R_LARCH #46229
+pkg debug/elf, const R_LARCH_IRELATIVE = 12 #46229
+pkg debug/elf, const R_LARCH_IRELATIVE R_LARCH #46229
+pkg debug/elf, const R_LARCH_JUMP_SLOT = 5 #46229
+pkg debug/elf, const R_LARCH_JUMP_SLOT R_LARCH #46229
+pkg debug/elf, const R_LARCH_MARK_LA = 20 #46229
+pkg debug/elf, const R_LARCH_MARK_LA R_LARCH #46229
+pkg debug/elf, const R_LARCH_MARK_PCREL = 21 #46229
+pkg debug/elf, const R_LARCH_MARK_PCREL R_LARCH #46229
+pkg debug/elf, const R_LARCH_NONE = 0 #46229
+pkg debug/elf, const R_LARCH_NONE R_LARCH #46229
+pkg debug/elf, const R_LARCH_RELATIVE = 3 #46229
+pkg debug/elf, const R_LARCH_RELATIVE R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_ADD = 35 #46229
+pkg debug/elf, const R_LARCH_SOP_ADD R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_AND = 36 #46229
+pkg debug/elf, const R_LARCH_SOP_AND R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_ASSERT = 30 #46229
+pkg debug/elf, const R_LARCH_SOP_ASSERT R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_IF_ELSE = 37 #46229
+pkg debug/elf, const R_LARCH_SOP_IF_ELSE R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_NOT = 31 #46229
+pkg debug/elf, const R_LARCH_SOP_NOT R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_POP_32_S_0_10_10_16_S2 = 45 #46229
+pkg debug/elf, const R_LARCH_SOP_POP_32_S_0_10_10_16_S2 R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_POP_32_S_0_5_10_16_S2 = 44 #46229
+pkg debug/elf, const R_LARCH_SOP_POP_32_S_0_5_10_16_S2 R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_12 = 40 #46229
+pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_12 R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_16 = 41 #46229
+pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_16 R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_16_S2 = 42 #46229
+pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_16_S2 R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_5 = 38 #46229
+pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_5 R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_POP_32_S_5_20 = 43 #46229
+pkg debug/elf, const R_LARCH_SOP_POP_32_S_5_20 R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_POP_32_U = 46 #46229
+pkg debug/elf, const R_LARCH_SOP_POP_32_U R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_POP_32_U_10_12 = 39 #46229
+pkg debug/elf, const R_LARCH_SOP_POP_32_U_10_12 R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_PUSH_ABSOLUTE = 23 #46229
+pkg debug/elf, const R_LARCH_SOP_PUSH_ABSOLUTE R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_PUSH_DUP = 24 #46229
+pkg debug/elf, const R_LARCH_SOP_PUSH_DUP R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_PUSH_GPREL = 25 #46229
+pkg debug/elf, const R_LARCH_SOP_PUSH_GPREL R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_PUSH_PCREL = 22 #46229
+pkg debug/elf, const R_LARCH_SOP_PUSH_PCREL R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_PUSH_PLT_PCREL = 29 #46229
+pkg debug/elf, const R_LARCH_SOP_PUSH_PLT_PCREL R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_PUSH_TLS_GD = 28 #46229
+pkg debug/elf, const R_LARCH_SOP_PUSH_TLS_GD R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_PUSH_TLS_GOT = 27 #46229
+pkg debug/elf, const R_LARCH_SOP_PUSH_TLS_GOT R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_PUSH_TLS_TPREL = 26 #46229
+pkg debug/elf, const R_LARCH_SOP_PUSH_TLS_TPREL R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_SL = 33 #46229
+pkg debug/elf, const R_LARCH_SOP_SL R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_SR = 34 #46229
+pkg debug/elf, const R_LARCH_SOP_SR R_LARCH #46229
+pkg debug/elf, const R_LARCH_SOP_SUB = 32 #46229
+pkg debug/elf, const R_LARCH_SOP_SUB R_LARCH #46229
+pkg debug/elf, const R_LARCH_SUB16 = 53 #46229
+pkg debug/elf, const R_LARCH_SUB16 R_LARCH #46229
+pkg debug/elf, const R_LARCH_SUB24 = 54 #46229
+pkg debug/elf, const R_LARCH_SUB24 R_LARCH #46229
+pkg debug/elf, const R_LARCH_SUB32 = 55 #46229
+pkg debug/elf, const R_LARCH_SUB32 R_LARCH #46229
+pkg debug/elf, const R_LARCH_SUB64 = 56 #46229
+pkg debug/elf, const R_LARCH_SUB64 R_LARCH #46229
+pkg debug/elf, const R_LARCH_SUB8 = 52 #46229
+pkg debug/elf, const R_LARCH_SUB8 R_LARCH #46229
+pkg debug/elf, const R_LARCH_TLS_DTPMOD32 = 6 #46229
+pkg debug/elf, const R_LARCH_TLS_DTPMOD32 R_LARCH #46229
+pkg debug/elf, const R_LARCH_TLS_DTPMOD64 = 7 #46229
+pkg debug/elf, const R_LARCH_TLS_DTPMOD64 R_LARCH #46229
+pkg debug/elf, const R_LARCH_TLS_DTPREL32 = 8 #46229
+pkg debug/elf, const R_LARCH_TLS_DTPREL32 R_LARCH #46229
+pkg debug/elf, const R_LARCH_TLS_DTPREL64 = 9 #46229
+pkg debug/elf, const R_LARCH_TLS_DTPREL64 R_LARCH #46229
+pkg debug/elf, const R_LARCH_TLS_TPREL32 = 10 #46229
+pkg debug/elf, const R_LARCH_TLS_TPREL32 R_LARCH #46229
+pkg debug/elf, const R_LARCH_TLS_TPREL64 = 11 #46229
+pkg debug/elf, const R_LARCH_TLS_TPREL64 R_LARCH #46229
+pkg debug/elf, method (R_LARCH) GoString() string #46229
+pkg debug/elf, method (R_LARCH) String() string #46229
+pkg debug/elf, type R_LARCH int #46229

api/next/47005.txt

@@ -0,0 +1,2 @@
+pkg net/url, func JoinPath(string, ...string) (string, error) #47005
+pkg net/url, method (*URL) JoinPath(...string) *URL #47005

api/next/50340.txt

@@ -0,0 +1 @@
+pkg sort, func Find(int, func(int) int) (int, bool) #50340

api/next/50599.txt

@@ -0,0 +1 @@
+pkg os/exec, method (*Cmd) Environ() []string #50599

api/next/50601.txt

@@ -0,0 +1,5 @@
+pkg encoding/binary, type AppendByteOrder interface { AppendUint16, AppendUint32, AppendUint64, String } #50601
+pkg encoding/binary, type AppendByteOrder interface, AppendUint16([]uint8, uint16) []uint8 #50601
+pkg encoding/binary, type AppendByteOrder interface, AppendUint32([]uint8, uint32) []uint8 #50601
+pkg encoding/binary, type AppendByteOrder interface, AppendUint64([]uint8, uint64) []uint8 #50601
+pkg encoding/binary, type AppendByteOrder interface, String() string #50601

api/next/50674.txt

@@ -0,0 +1,9 @@
+pkg crypto/x509, func ParseRevocationList([]uint8) (*RevocationList, error) #50674
+pkg crypto/x509, method (*RevocationList) CheckSignatureFrom(*Certificate) error #50674
+pkg crypto/x509, type RevocationList struct, AuthorityKeyId []uint8 #50674
+pkg crypto/x509, type RevocationList struct, Extensions []pkix.Extension #50674
+pkg crypto/x509, type RevocationList struct, Issuer pkix.Name #50674
+pkg crypto/x509, type RevocationList struct, Raw []uint8 #50674
+pkg crypto/x509, type RevocationList struct, RawIssuer []uint8 #50674
+pkg crypto/x509, type RevocationList struct, RawTBSRevocationList []uint8 #50674
+pkg crypto/x509, type RevocationList struct, Signature []uint8 #50674

api/next/51082.txt

@@ -0,0 +1,61 @@
+pkg go/doc, method (*Package) HTML(string) []uint8 #51082
+pkg go/doc, method (*Package) Markdown(string) []uint8 #51082
+pkg go/doc, method (*Package) Parser() *comment.Parser #51082
+pkg go/doc, method (*Package) Printer() *comment.Printer #51082
+pkg go/doc, method (*Package) Synopsis(string) string #51082
+pkg go/doc, method (*Package) Text(string) []uint8 #51082
+pkg go/doc/comment, func DefaultLookupPackage(string) (string, bool) #51082
+pkg go/doc/comment, method (*DocLink) DefaultURL(string) string #51082
+pkg go/doc/comment, method (*Heading) DefaultID() string #51082
+pkg go/doc/comment, method (*List) BlankBefore() bool #51082
+pkg go/doc/comment, method (*List) BlankBetween() bool #51082
+pkg go/doc/comment, method (*Parser) Parse(string) *Doc #51082
+pkg go/doc/comment, method (*Printer) Comment(*Doc) []uint8 #51082
+pkg go/doc/comment, method (*Printer) HTML(*Doc) []uint8 #51082
+pkg go/doc/comment, method (*Printer) Markdown(*Doc) []uint8 #51082
+pkg go/doc/comment, method (*Printer) Text(*Doc) []uint8 #51082
+pkg go/doc/comment, type Block interface, unexported methods #51082
+pkg go/doc/comment, type Code struct #51082
+pkg go/doc/comment, type Code struct, Text string #51082
+pkg go/doc/comment, type Doc struct #51082
+pkg go/doc/comment, type Doc struct, Content []Block #51082
+pkg go/doc/comment, type Doc struct, Links []*LinkDef #51082
+pkg go/doc/comment, type DocLink struct #51082
+pkg go/doc/comment, type DocLink struct, ImportPath string #51082
+pkg go/doc/comment, type DocLink struct, Name string #51082
+pkg go/doc/comment, type DocLink struct, Recv string #51082
+pkg go/doc/comment, type DocLink struct, Text []Text #51082
+pkg go/doc/comment, type Heading struct #51082
+pkg go/doc/comment, type Heading struct, Text []Text #51082
+pkg go/doc/comment, type Italic string #51082
+pkg go/doc/comment, type Link struct #51082
+pkg go/doc/comment, type Link struct, Auto bool #51082
+pkg go/doc/comment, type Link struct, Text []Text #51082
+pkg go/doc/comment, type Link struct, URL string #51082
+pkg go/doc/comment, type LinkDef struct #51082
+pkg go/doc/comment, type LinkDef struct, Text string #51082
+pkg go/doc/comment, type LinkDef struct, URL string #51082
+pkg go/doc/comment, type LinkDef struct, Used bool #51082
+pkg go/doc/comment, type List struct #51082
+pkg go/doc/comment, type List struct, ForceBlankBefore bool #51082
+pkg go/doc/comment, type List struct, ForceBlankBetween bool #51082
+pkg go/doc/comment, type List struct, Items []*ListItem #51082
+pkg go/doc/comment, type ListItem struct #51082
+pkg go/doc/comment, type ListItem struct, Content []Block #51082
+pkg go/doc/comment, type ListItem struct, Number string #51082
+pkg go/doc/comment, type Paragraph struct #51082
+pkg go/doc/comment, type Paragraph struct, Text []Text #51082
+pkg go/doc/comment, type Parser struct #51082
+pkg go/doc/comment, type Parser struct, LookupPackage func(string) (string, bool) #51082
+pkg go/doc/comment, type Parser struct, LookupSym func(string, string) bool #51082
+pkg go/doc/comment, type Parser struct, Words map[string]string #51082
+pkg go/doc/comment, type Plain string #51082
+pkg go/doc/comment, type Printer struct #51082
+pkg go/doc/comment, type Printer struct, DocLinkBaseURL string #51082
+pkg go/doc/comment, type Printer struct, DocLinkURL func(*DocLink) string #51082
+pkg go/doc/comment, type Printer struct, HeadingID func(*Heading) string #51082
+pkg go/doc/comment, type Printer struct, HeadingLevel int #51082
+pkg go/doc/comment, type Printer struct, TextCodePrefix string #51082
+pkg go/doc/comment, type Printer struct, TextPrefix string #51082
+pkg go/doc/comment, type Printer struct, TextWidth int #51082
+pkg go/doc/comment, type Text interface, unexported methods #51082

api/next/51414.txt

@@ -0,0 +1 @@
+pkg time, method (Duration) Abs() Duration #51414

api/next/51644.txt

@@ -0,0 +1,2 @@
+pkg encoding/binary, func AppendUvarint([]uint8, uint64) []uint8 #51644
+pkg encoding/binary, func AppendVarint([]uint8, int64) []uint8 #51644

api/next/51684.txt

@@ -0,0 +1,2 @@
+pkg regexp/syntax, const ErrNestingDepth = "expression nests too deeply" #51684
+pkg regexp/syntax, const ErrNestingDepth ErrorCode #51684

api/next/51868.txt

@@ -0,0 +1,36 @@
+pkg debug/pe, const IMAGE_COMDAT_SELECT_ANY = 2 #51686
+pkg debug/pe, const IMAGE_COMDAT_SELECT_ANY ideal-int #51686
+pkg debug/pe, const IMAGE_COMDAT_SELECT_ASSOCIATIVE = 5 #51686
+pkg debug/pe, const IMAGE_COMDAT_SELECT_ASSOCIATIVE ideal-int #51686
+pkg debug/pe, const IMAGE_COMDAT_SELECT_EXACT_MATCH = 4 #51686
+pkg debug/pe, const IMAGE_COMDAT_SELECT_EXACT_MATCH ideal-int #51686
+pkg debug/pe, const IMAGE_COMDAT_SELECT_LARGEST = 6 #51686
+pkg debug/pe, const IMAGE_COMDAT_SELECT_LARGEST ideal-int #51686
+pkg debug/pe, const IMAGE_COMDAT_SELECT_NODUPLICATES = 1 #51686
+pkg debug/pe, const IMAGE_COMDAT_SELECT_NODUPLICATES ideal-int #51686
+pkg debug/pe, const IMAGE_COMDAT_SELECT_SAME_SIZE = 3 #51686
+pkg debug/pe, const IMAGE_COMDAT_SELECT_SAME_SIZE ideal-int #51686
+pkg debug/pe, const IMAGE_SCN_CNT_CODE = 32 #51686
+pkg debug/pe, const IMAGE_SCN_CNT_CODE ideal-int #51686
+pkg debug/pe, const IMAGE_SCN_CNT_INITIALIZED_DATA = 64 #51686
+pkg debug/pe, const IMAGE_SCN_CNT_INITIALIZED_DATA ideal-int #51686
+pkg debug/pe, const IMAGE_SCN_CNT_UNINITIALIZED_DATA = 128 #51686
+pkg debug/pe, const IMAGE_SCN_CNT_UNINITIALIZED_DATA ideal-int #51686
+pkg debug/pe, const IMAGE_SCN_LNK_COMDAT = 4096 #51686
+pkg debug/pe, const IMAGE_SCN_LNK_COMDAT ideal-int #51686
+pkg debug/pe, const IMAGE_SCN_MEM_DISCARDABLE = 33554432 #51686
+pkg debug/pe, const IMAGE_SCN_MEM_DISCARDABLE ideal-int #51686
+pkg debug/pe, const IMAGE_SCN_MEM_EXECUTE = 536870912 #51686
+pkg debug/pe, const IMAGE_SCN_MEM_EXECUTE ideal-int #51686
+pkg debug/pe, const IMAGE_SCN_MEM_READ = 1073741824 #51686
+pkg debug/pe, const IMAGE_SCN_MEM_READ ideal-int #51686
+pkg debug/pe, const IMAGE_SCN_MEM_WRITE = 2147483648 #51686
+pkg debug/pe, const IMAGE_SCN_MEM_WRITE ideal-int #51686
+pkg debug/pe, method (*File) COFFSymbolReadSectionDefAux(int) (*COFFSymbolAuxFormat5, error) #51686
+pkg debug/pe, type COFFSymbolAuxFormat5 struct #51686
+pkg debug/pe, type COFFSymbolAuxFormat5 struct, Checksum uint32 #51686
+pkg debug/pe, type COFFSymbolAuxFormat5 struct, NumLineNumbers uint16 #51686
+pkg debug/pe, type COFFSymbolAuxFormat5 struct, NumRelocs uint16 #51686
+pkg debug/pe, type COFFSymbolAuxFormat5 struct, SecNum uint16 #51686
+pkg debug/pe, type COFFSymbolAuxFormat5 struct, Selection uint8 #51686
+pkg debug/pe, type COFFSymbolAuxFormat5 struct, Size uint32 #51686

api/next/74958.txt

@@ -1 +0,0 @@
-pkg go/scanner, method (*Scanner) End() token.Pos #74958

api/next/75500.txt

@@ -1 +0,0 @@
-pkg net/http, type Server struct, DisableClientPriority bool #75500

api/next/77266.txt

@@ -1,16 +0,0 @@
-pkg unicode, const Version = "17.0.0" #77266
-pkg unicode, var Beria_Erfe *RangeTable #77266
-pkg unicode, var Garay *RangeTable #77266
-pkg unicode, var Gurung_Khema *RangeTable #77266
-pkg unicode, var IDS_Unary_Operator *RangeTable #77266
-pkg unicode, var ID_Compat_Math_Continue *RangeTable #77266
-pkg unicode, var ID_Compat_Math_Start *RangeTable #77266
-pkg unicode, var Kirat_Rai *RangeTable #77266
-pkg unicode, var Modifier_Combining_Mark *RangeTable #77266
-pkg unicode, var Ol_Onal *RangeTable #77266
-pkg unicode, var Sidetic *RangeTable #77266
-pkg unicode, var Sunuwar *RangeTable #77266
-pkg unicode, var Tai_Yo *RangeTable #77266
-pkg unicode, var Todhri *RangeTable #77266
-pkg unicode, var Tolong_Siki *RangeTable #77266
-pkg unicode, var Tulu_Tigalari *RangeTable #77266

codereview.cfg

@@ -1 +1,2 @@
-branch: master
+branch: dev.boringcrypto
+parent-branch: master

doc/README.md

@@ -1,75 +0,0 @@
-# Release Notes
-
-The `initial` and `next` subdirectories of this directory are for release notes.
-
-## For developers
-
-Release notes should be added to `next` by editing existing files or creating
-new files. **Do not add RELNOTE=yes comments in CLs.** Instead, add a file to
-the CL (or ask the author to do so).
-
-At the end of the development cycle, the files will be merged by being
-concatenated in sorted order by pathname. Files in the directory matching the
-glob "*stdlib/*minor" are treated specially. They should be in subdirectories
-corresponding to standard library package paths, and headings for those package
-paths will be generated automatically.
-
-Files in this repo's `api/next` directory must have corresponding files in
-`doc/next/*stdlib/*minor`.
-The files should be in the subdirectory for the package with the new
-API, and should be named after the issue number of the API proposal.
-For example, if the directory `6-stdlib/99-minor` is present,
-then an `api/next` file with the line
-
-    pkg net/http, function F #12345
-
-should have a corresponding file named `doc/next/6-stdlib/99-minor/net/http/12345.md`.
-At a minimum, that file should contain either a full sentence or a TODO,
-ideally referring to a person with the responsibility to complete the note.
-
-If your CL addresses an accepted proposal, mention the proposal issue number in
-your release note in the form `/issue/NUMBER`. A link to the issue in the text
-will have this form (see below). If you don't want to mention the issue in the
-text, add it as a comment:
-```
-<!-- go.dev/issue/12345 -->
-```
-If an accepted proposal is mentioned in a CL but not in the release notes, it will be
-flagged as a TODO by the automated tooling. That is true even for proposals that add API.
-
-Use the following forms in your markdown:
-
-	[http.Request]                     # symbol documentation; auto-linked as in Go doc strings
-	[Request]                          # short form, for symbols in the package being documented
-	[net/http]                         # package link
-	[#12345](/issue/12345)             # GitHub issues
-	[CL 6789](/cl/6789)                # Gerrit changelists
-
-To preview `next` content in merged form using a local instance of the website, run:
-
-```
-go run golang.org/x/website/cmd/golangorg@latest -goroot=..
-```
-
-Then open http://localhost:6060/doc/next. Refresh the page to see your latest edits.
-
-## For the release team
-
-The `relnote` tool, at `golang.org/x/build/cmd/relnote`, operates on the files
-in `doc/next`.
-
-As a release cycle nears completion, run `relnote todo` to get a list of
-unfinished release note work.
-
-To prepare the release notes for a release, run `relnote generate`.
-That will merge the `.md` files in `next` into a single file.
-Atomically (as close to it as possible) add that file to `_content/doc` directory
-of the website repository and remove the `doc/next` directory in this repository.
-
-To begin the next release development cycle, populate the contents of `next`
-with those of `initial`. From the repo root:
-
-    > cd doc
-    > cp -R initial/ next
-
-Then edit `next/1-intro.md` to refer to the next version.

doc/asm.html

@@ -464,23 +464,6 @@ Function is the outermost frame of the call stack. Traceback should stop at this
 </li>
 </ul>
 
-<h3 id="special-instructions">Special instructions</h3>
-
-<p>
-The <code>PCALIGN</code> pseudo-instruction is used to indicate that the next instruction should be aligned
-to a specified boundary by padding with no-op instructions.
-</p>
-
-<p>
-It is currently supported on arm64, amd64, ppc64, loong64 and riscv64.
-
-For example, the start of the <code>MOVD</code> instruction below is aligned to 32 bytes:
-<pre>
-PCALIGN $32
-MOVD $2, R0
-</pre>
-</p>
-
 <h3 id="data-offsets">Interacting with Go types and constants</h3>
 
 <p>
@@ -1039,12 +1022,6 @@ The value of <code>GOMIPS64</code> environment variable (<code>hardfloat</code>
 <code>GOMIPS64_hardfloat</code> or <code>GOMIPS64_softfloat</code>.
 </p>
 
-<h3 id="riscv64">RISCV64</h3>
-
-<p>
-Reference: <a href="/pkg/cmd/internal/obj/riscv">Go RISCV64 Assembly Instructions Reference Manual</a>
-</p>
-
 <h3 id="unsupported_opcodes">Unsupported opcodes</h3>
 
 <p>

doc/go1.19.html

@@ -0,0 +1,179 @@
+<!--{
+	"Title": "Go 1.19 Release Notes",
+	"Path":  "/doc/go1.19"
+}-->
+<!--
+NOTE: In this document and others in this directory, the convention is to
+set fixed-width phrases with non-fixed-width spaces, as in
+<code>hello</code> <code>world</code>.
+Do not send CLs removing the interior tags from such phrases.
+-->
+<style>
+  main ul li { margin: 0.5em 0; }
+</style>
+<h2 id="introduction">DRAFT RELEASE NOTES — Introduction to Go 1.19</h2>
+<p>
+  <strong>
+    Go 1.19 is not yet released. These are work-in-progress
+    release notes. Go 1.19 is expected to be released in August 2022.
+  </strong>
+</p>
+<h2 id="language">Changes to the language</h2>
+<p>
+  TODO: complete this section
+</p>
+<h2 id="ports">Ports</h2>
+<p>
+  TODO: complete this section, or delete if not needed
+</p>
+<h2 id="tools">Tools</h2>
+<p>
+  TODO: complete this section, or delete if not needed
+</p>
+<h3 id="go-command">Go command</h3>
+<p>
+  TODO: complete this section.
+</p>
+
+<!-- https://go.dev/issue/51461 -->
+<p>
+  The <code>-trimpath</code> flag, if set, is now included in the build settings
+  stamped into Go binaries by <code>go</code> <code>build</code>, and can be
+  examined using
+  <a href="https://pkg.go.dev/cmd/go#hdr-Print_Go_version"><code>go</code> <code>version</code> <code>-m</code></a>
+  or <a href="https://pkg.go.dev/runtime/debug#ReadBuildInfo"><code>debug.ReadBuildInfo</code></a>.
+</p>
+<p>
+  <code>go</code> <code>generate</code> now sets the <code>GOROOT</code>
+  environment variable explicitly in the generator's environment, so that
+  generators can locate the correct <code>GOROOT</code> even if built
+  with <code>-trimpath</code>.
+</p>
+
+<h4 id="go-unix">New <code>unix</code> build constraint</h4>
+
+<p><!-- CL 389934 -->
+  The build constraint <code>unix</code> is now recognized
+  in <code>//go:build</code> lines. The constraint is satisfied
+  if the target operating system, also known as <code>GOOS</code>, is
+  a Unix or Unix-like system. For the 1.19 release it is satisfied
+  if <code>GOOS</code> is one of
+  <code>aix</code>, <code>android</code>, <code>darwin</code>,
+  <code>dragonfly</code>, <code>freebsd</code>, <code>hurd</code>,
+  <code>illumos</code>, <code>ios</code>, <code>linux</code>,
+  <code>netbsd</code>, <code>openbsd</code>, or <code>solaris</code>.
+  In future releases the <code>unix</code> constraint may match
+  additional newly supported operating systems.
+</p>
+
+<h2 id="runtime">Runtime</h2>
+<p>
+  TODO: complete this section, or delete if not needed
+</p>
+<h2 id="compiler">Compiler</h2>
+<p>
+  TODO: complete this section, or delete if not needed
+</p>
+<h2 id="linker">Linker</h2>
+<p>
+  TODO: complete this section, or delete if not needed
+</p>
+<h2 id="library">Core library</h2>
+<p>
+  TODO: complete this section
+</p>
+<h3 id="minor_library_changes">Minor changes to the library</h3>
+<p>
+  As always, there are various minor changes and updates to the library,
+  made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
+  in mind.
+</p>
+<p>
+  TODO: complete this section
+</p>
+
+<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
+  <dd>
+    <p><!-- CL 400974 -->
+      The <code>tls10default</code> <code>GODEBUG</code> option has been
+      removed. It is still possible to enable TLS 1.0 client-side by setting
+      <code>Config.MinVersion</code>.
+    </p>
+  </dd>
+</dl><!-- crypto/tls -->
+
+<dl id="image/draw"><dt><a href="/pkg/image/draw/">image/draw</a></dt>
+  <dd>
+    <p><!-- CL 396795 -->
+      <code>Draw</code> with the <code>Src</code> operator preserves
+      non-premultiplied-alpha colors when destination and source images are
+      both <code>*image.NRGBA</code> (or both <code>*image.NRGBA64</code>).
+      This reverts a behavior change accidentally introduced by a Go 1.18
+      library optimization, to match the behavior in Go 1.17 and earlier.
+    </p>
+  </dd>
+</dl><!-- image/draw -->
+
+<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
+  <dd>
+    <p><!-- CL 386016 -->
+      The pure Go resolver will now use EDNS(0) to include a suggested
+      maximum reply packet length, permitting reply packets to contain
+      up to 1232 bytes (the previous maximum was 512).
+      In the unlikely event that this causes problems with a local DNS
+      resolver, setting the environment variable
+      <code>GODEBUG=netdns=cgo</code> to use the cgo-based resolver
+      should work.
+      Please report any such problems on <a href="/issue/new">the
+      issue tracker</a>.
+    </p>
+
+    <p><!-- CL 396877 -->
+      When a net package function or method returns an "I/O timeout"
+      error, the error will now satisfy <code>errors.Is(err,
+      context.DeadlineExceeded)</code>.  When a net package function
+      returns an "operation was canceled" error, the error will now
+      satisfy <code>errors.Is(err, context.Canceled)</code>.
+      These changes are intended to make it easier for code to test
+      for cases in which a context cancelation or timeout causes a net
+      package function or method to return an error, while preserving
+      backward compatibility for error messages.
+    </p>
+  </dd>
+</dl><!-- net -->
+
+<dl id="os/exec"><dt><a href="/pkg/os/exec/">os/exec</a></dt>
+  <dd><!-- https://go.dev/issue/50599 -->
+    <p>
+      An <code>exec.Cmd</code> with a non-empty <code>Dir</code> and a
+      nil <code>Env</code> now implicitly sets the <code>PWD</code> environment
+      variable for the subprocess to match <code>Dir</code>.
+    </p>
+    <p>
+      The new method <code>(*exec.Cmd).Environ</code> reports the
+      environment that would be used to run the command, including the
+      aforementioned <code>PWD</code> variable.
+    </p>
+  </dd>
+</dl> <!-- os/exec -->
+
+<dl id="runtime"><dt><a href="/pkg/runtime/">runtime</a></dt>
+  <dd>
+    <p><!-- https://go.dev/issue/51461 -->
+      The <code>GOROOT</code> function now returns the empty string
+      (instead of <code>"go"</code>) when the binary was built with
+      the <code>-trimpath</code> flag set and the <code>GOROOT</code>
+      variable is not set in the process environment.
+    </p>
+  </dd>
+</dl><!-- runtime -->
+
+<dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
+  <dd>
+    <p><!-- CL 397255 -->
+      <a href="/pkg/strconv/#strconv.Quote"><code>strconv.Quote</code></a>
+      and related functions now quote the rune 007F as <code>\x7f</code>,
+      not <code>\u007f</code>.
+    </p>
+  </dd>
+</dl><!-- strconv -->

doc/go_mem.html

@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Memory Model",
-	"Subtitle": "Version of June 6, 2022",
+	"Subtitle": "Version of May 31, 2014",
 	"Path": "/ref/mem"
 }-->
 
@@ -8,9 +8,12 @@
 p.rule {
   font-style: italic;
 }
+span.event {
+  font-style: italic;
+}
 </style>
 
-<h2 id="introduction">Introduction</h2>
+<h2>Introduction</h2>
 
 <p>
 The Go memory model specifies the conditions under which
@@ -19,7 +22,7 @@ observe values produced by writes to the same variable in a different goroutine.
 </p>
 
 
-<h3 id="advice">Advice</h3>
+<h2>Advice</h2>
 
 <p>
 Programs that modify data being simultaneously accessed by multiple goroutines
@@ -41,249 +44,90 @@ you are being too clever.
 Don't be clever.
 </p>
 
-<h3 id="overview">Informal Overview</h3>
+<h2>Happens Before</h2>
 
 <p>
-Go approaches its memory model in much the same way as the rest of the language,
-aiming to keep the semantics simple, understandable, and useful.
-This section gives a general overview of the approach and should suffice for most programmers.
-The memory model is specified more formally in the next section.
+Within a single goroutine, reads and writes must behave
+as if they executed in the order specified by the program.
+That is, compilers and processors may reorder the reads and writes
+executed within a single goroutine only when the reordering
+does not change the behavior within that goroutine
+as defined by the language specification.
+Because of this reordering, the execution order observed
+by one goroutine may differ from the order perceived
+by another.  For example, if one goroutine
+executes <code>a = 1; b = 2;</code>, another might observe
+the updated value of <code>b</code> before the updated value of <code>a</code>.
 </p>
 
 <p>
-A <em>data race</em> is defined as
-a write to a memory location happening concurrently with another read or write to that same location,
-unless all the accesses involved are atomic data accesses as provided by the <code>sync/atomic</code> package.
-As noted already, programmers are strongly encouraged to use appropriate synchronization
-to avoid data races.
-In the absence of data races, Go programs behave as if all the goroutines
-were multiplexed onto a single processor.
-This property is sometimes referred to as DRF-SC: data-race-free programs
-execute in a sequentially consistent manner.
+To specify the requirements of reads and writes, we define
+<i>happens before</i>, a partial order on the execution
+of memory operations in a Go program.  If event <span class="event">e<sub>1</sub></span> happens
+before event <span class="event">e<sub>2</sub></span>, then we say that <span class="event">e<sub>2</sub></span> happens after <span class="event">e<sub>1</sub></span>.
+Also, if <span class="event">e<sub>1</sub></span> does not happen before <span class="event">e<sub>2</sub></span> and does not happen
+after <span class="event">e<sub>2</sub></span>, then we say that <span class="event">e<sub>1</sub></span> and <span class="event">e<sub>2</sub></span> happen concurrently.
+</p>
+
+<p class="rule">
+Within a single goroutine, the happens-before order is the
+order expressed by the program.
 </p>
 
 <p>
-While programmers should write Go programs without data races,
-there are limitations to what a Go implementation can do in response to a data race.
-An implementation may always react to a data race by reporting the race and terminating the program.
-Otherwise, each read of a single-word-sized or sub-word-sized memory location
-must observe a value actually written to that location (perhaps by a concurrent executing goroutine)
-and not yet overwritten.
-These implementation constraints make Go more like Java or JavaScript,
-in that most races have a limited number of outcomes,
-and less like C and C++, where the meaning of any program with a race
-is entirely undefined, and the compiler may do anything at all.
-Go's approach aims to make errant programs more reliable and easier to debug,
-while still insisting that races are errors and that tools can diagnose and report them.
-</p>
-
-<h2 id="model">Memory Model</h2>
-
-<p>
-The following formal definition of Go's memory model closely follows
-the approach presented by Hans-J. Boehm and Sarita V. Adve in
-“<a href="https://dl.acm.org/doi/10.1145/1375581.1375591">Foundations of the C++ Concurrency Memory Model</a>”,
-published in PLDI 2008.
-The definition of data-race-free programs and the guarantee of sequential consistency
-for race-free programs are equivalent to the ones in that work.
-</p>
-
-<p>
-The memory model describes the requirements on program executions,
-which are made up of goroutine executions,
-which in turn are made up of memory operations.
-</p>
-
-<p>
-A <i>memory operation</i> is modeled by four details:
-</p>
-<ul>
-	<li>its kind, indicating whether it is an ordinary data read, an ordinary data write,
-    or a <i>synchronizing operation</i> such as an atomic data access,
-	a mutex operation, or a channel operation,</li>
-	<li>its location in the program,</li>
-	<li>the memory location or variable being accessed, and</li>
-	<li>the values read or written by the operation.</li>
-</ul>
-<p>
-Some memory operations are <i>read-like</i>, including read, atomic read, mutex lock, and channel receive.
-Other memory operations are <i>write-like</i>, including write, atomic write, mutex unlock, channel send, and channel close.
-Some, such as atomic compare-and-swap, are both read-like and write-like.
-</p>
-
-<p>
-A <i>goroutine execution</i> is modeled as a set of memory operations executed by a single goroutine.
-</p>
-
-<p>
-<b>Requirement 1</b>:
-The memory operations in each goroutine must correspond to a correct sequential execution of that goroutine,
-given the values read from and written to memory.
-That execution must be consistent with the <i>sequenced before</i> relation,
-defined as the partial order requirements set out by the <a href="/ref/spec">Go language specification</a>
-for Go's control flow constructs as well as the <a href="/ref/spec#Order_of_evaluation">order of evaluation for expressions</a>.
-</p>
-
-<p>
-A Go <i>program execution</i> is modeled as a set of goroutine executions,
-together with a mapping <i>W</i> that specifies the write-like operation that each read-like operation reads from.
-(Multiple executions of the same program can have different program executions.)
-</p>
-
-<p>
-<b>Requirement 2</b>:
-For a given program execution, the mapping <i>W</i>, when limited to synchronizing operations,
-must be explainable by some implicit total order of the synchronizing operations
-that is consistent with sequencing and the values read and written by those operations.
-</p>
-
-<p>
-The <i>synchronized before</i> relation is a partial order on synchronizing memory operations,
-derived from <i>W</i>.
-If a synchronizing read-like memory operation <i>r</i>
-observes a synchronizing write-like memory operation <i>w</i>
-(that is, if <i>W</i>(<i>r</i>) = <i>w</i>),
-then <i>w</i> is synchronized before <i>r</i>.
-Informally, the synchronized before relation is a subset of the implied total order
-mentioned in the previous paragraph,
-limited to the information that <i>W</i> directly observes.
-</p>
-
-<p>
-The <i>happens before</i> relation is defined as the transitive closure of the
-union of the sequenced before and synchronized before relations.
-</p>
-
-<p>
-<b>Requirement 3</b>:
-For an ordinary (non-synchronizing) data read <i>r</i> on a memory location <i>x</i>,
-<i>W</i>(<i>r</i>) must be a write <i>w</i> that is <i>visible</i> to <i>r</i>,
-where visible means that both of the following hold:
+A read <span class="event">r</span> of a variable <code>v</code> is <i>allowed</i> to observe a write <span class="event">w</span> to <code>v</code>
+if both of the following hold:
 </p>
 
 <ol>
-	<li><i>w</i> happens before <i>r</i>.</li>
-	<li><i>w</i> does not happen before any other write <i>w'</i> (to <i>x</i>) that happens before <i>r</i>.</li>
+<li><span class="event">r</span> does not happen before <span class="event">w</span>.</li>
+<li>There is no other write <span class="event">w'</span> to <code>v</code> that happens
+    after <span class="event">w</span> but before <span class="event">r</span>.</li>
 </ol>
 
 <p>
-A <i>read-write data race</i> on memory location <i>x</i>
-consists of a read-like memory operation <i>r</i> on <i>x</i>
-and a write-like memory operation <i>w</i> on <i>x</i>,
-at least one of which is non-synchronizing,
-which are unordered by happens before
-(that is, neither <i>r</i> happens before <i>w</i>
-nor <i>w</i> happens before <i>r</i>).
+To guarantee that a read <span class="event">r</span> of a variable <code>v</code> observes a
+particular write <span class="event">w</span> to <code>v</code>, ensure that <span class="event">w</span> is the only
+write <span class="event">r</span> is allowed to observe.
+That is, <span class="event">r</span> is <i>guaranteed</i> to observe <span class="event">w</span> if both of the following hold:
+</p>
+
+<ol>
+<li><span class="event">w</span> happens before <span class="event">r</span>.</li>
+<li>Any other write to the shared variable <code>v</code>
+either happens before <span class="event">w</span> or after <span class="event">r</span>.</li>
+</ol>
+
+<p>
+This pair of conditions is stronger than the first pair;
+it requires that there are no other writes happening
+concurrently with <span class="event">w</span> or <span class="event">r</span>.
 </p>
 
 <p>
-A <i>write-write data race</i> on memory location <i>x</i>
-consists of two write-like memory operations <i>w</i> and <i>w'</i> on <i>x</i>,
-at least one of which is non-synchronizing,
-which are unordered by happens before.
+Within a single goroutine,
+there is no concurrency, so the two definitions are equivalent:
+a read <span class="event">r</span> observes the value written by the most recent write <span class="event">w</span> to <code>v</code>.
+When multiple goroutines access a shared variable <code>v</code>,
+they must use synchronization events to establish
+happens-before conditions that ensure reads observe the
+desired writes.
 </p>
 
 <p>
-Note that if there are no read-write or write-write data races on memory location <i>x</i>,
-then any read <i>r</i> on <i>x</i> has only one possible <i>W</i>(<i>r</i>):
-the single <i>w</i> that immediately precedes it in the happens before order.
+The initialization of variable <code>v</code> with the zero value
+for <code>v</code>'s type behaves as a write in the memory model.
 </p>
 
 <p>
-More generally, it can be shown that any Go program that is data-race-free,
-meaning it has no program executions with read-write or write-write data races,
-can only have outcomes explained by some sequentially consistent interleaving
-of the goroutine executions.
-(The proof is the same as Section 7 of Boehm and Adve's paper cited above.)
-This property is called DRF-SC.
+Reads and writes of values larger than a single machine word
+behave as multiple machine-word-sized operations in an
+unspecified order.
 </p>
 
-<p>
-The intent of the formal definition is to match
-the DRF-SC guarantee provided to race-free programs
-by other languages, including C, C++, Java, JavaScript, Rust, and Swift.
-</p>
+<h2>Synchronization</h2>
 
-<p>
-Certain Go language operations such as goroutine creation and memory allocation
-act as synchronization operations.
-The effect of these operations on the synchronized-before partial order
-is documented in the “Synchronization” section below.
-Individual packages are responsible for providing similar documentation
-for their own operations.
-</p>
-
-<h2 id="restrictions">Implementation Restrictions for Programs Containing Data Races</h2>
-
-<p>
-The preceding section gave a formal definition of data-race-free program execution.
-This section informally describes the semantics that implementations must provide
-for programs that do contain races.
-</p>
-
-<p>
-Any implementation can, upon detecting a data race,
-report the race and halt execution of the program.
-Implementations using ThreadSanitizer
-(accessed with “<code>go</code> <code>build</code> <code>-race</code>”)
-do exactly this.
-</p>
-
-<p>
-A read of an array, struct, or complex number
-may be implemented as a read of each individual sub-value
-(array element, struct field, or real/imaginary component),
-in any order.
-Similarly, a write of an array, struct, or complex number
-may be implemented as a write of each individual sub-value,
-in any order.
-</p>
-
-<p>
-A read <i>r</i> of a memory location <i>x</i>
-holding a value
-that is not larger than a machine word must observe
-some write <i>w</i> such that <i>r</i> does not happen before <i>w</i>
-and there is no write <i>w'</i> such that <i>w</i> happens before <i>w'</i>
-and <i>w'</i> happens before <i>r</i>.
-That is, each read must observe a value written by a preceding or concurrent write.
-</p>
-
-<p>
-Additionally, observation of acausal and “out of thin air” writes is disallowed.
-</p>
-
-<p>
-Reads of memory locations larger than a single machine word
-are encouraged but not required to meet the same semantics
-as word-sized memory locations,
-observing a single allowed write <i>w</i>.
-For performance reasons,
-implementations may instead treat larger operations
-as a set of individual machine-word-sized operations
-in an unspecified order.
-This means that races on multiword data structures
-can lead to inconsistent values not corresponding to a single write.
-When the values depend on the consistency
-of internal (pointer, length) or (pointer, type) pairs,
-as can be the case for interface values, maps,
-slices, and strings in most Go implementations,
-such races can in turn lead to arbitrary memory corruption.
-</p>
-
-<p>
-Examples of incorrect synchronization are given in the
-“Incorrect synchronization” section below.
-</p>
-
-<p>
-Examples of the limitations on implementations are given in the
-“Incorrect compilation” section below.
-</p>
-
-<h2 id="synchronization">Synchronization</h2>
-
-<h3 id="init">Initialization</h3>
+<h3>Initialization</h3>
 
 <p>
 Program initialization runs in a single goroutine,
@@ -297,15 +141,15 @@ If a package <code>p</code> imports package <code>q</code>, the completion of
 </p>
 
 <p class="rule">
-The completion of all <code>init</code> functions is synchronized before
-the start of the function <code>main.main</code>.
+The start of the function <code>main.main</code> happens after
+all <code>init</code> functions have finished.
 </p>
 
-<h3 id="go">Goroutine creation</h3>
+<h3>Goroutine creation</h3>
 
 <p class="rule">
 The <code>go</code> statement that starts a new goroutine
-is synchronized before the start of the goroutine's execution.
+happens before the goroutine's execution begins.
 </p>
 
 <p>
@@ -330,12 +174,11 @@ calling <code>hello</code> will print <code>"hello, world"</code>
 at some point in the future (perhaps after <code>hello</code> has returned).
 </p>
 
-<h3 id="goexit">Goroutine destruction</h3>
+<h3>Goroutine destruction</h3>
 
 <p>
-The exit of a goroutine is not guaranteed to be synchronized before
-any event in the program.
-For example, in this program:
+The exit of a goroutine is not guaranteed to happen before
+any event in the program.  For example, in this program:
 </p>
 
 <pre>
@@ -360,7 +203,7 @@ use a synchronization mechanism such as a lock or channel
 communication to establish a relative ordering.
 </p>
 
-<h3 id="chan">Channel communication</h3>
+<h3>Channel communication</h3>
 
 <p>
 Channel communication is the main method of synchronization
@@ -370,8 +213,8 @@ usually in a different goroutine.
 </p>
 
 <p class="rule">
-A send on a channel is synchronized before the completion of the
-corresponding receive from that channel.
+A send on a channel happens before the corresponding
+receive from that channel completes.
 </p>
 
 <p>
@@ -396,13 +239,13 @@ func main() {
 
 <p>
 is guaranteed to print <code>"hello, world"</code>.  The write to <code>a</code>
-is sequenced before the send on <code>c</code>, which is synchronized before
-the corresponding receive on <code>c</code> completes, which is sequenced before
+happens before the send on <code>c</code>, which happens before
+the corresponding receive on <code>c</code> completes, which happens before
 the <code>print</code>.
 </p>
 
 <p class="rule">
-The closing of a channel is synchronized before a receive that returns a zero value
+The closing of a channel happens before a receive that returns a zero value
 because the channel is closed.
 </p>
 
@@ -413,8 +256,8 @@ yields a program with the same guaranteed behavior.
 </p>
 
 <p class="rule">
-A receive from an unbuffered channel is synchronized before the completion of
-the corresponding send on that channel.
+A receive from an unbuffered channel happens before
+the send on that channel completes.
 </p>
 
 <p>
@@ -440,8 +283,8 @@ func main() {
 
 <p>
 is also guaranteed to print <code>"hello, world"</code>.  The write to <code>a</code>
-is sequenced before the receive on <code>c</code>, which is synchronized before
-the corresponding send on <code>c</code> completes, which is sequenced
+happens before the receive on <code>c</code>, which happens before
+the corresponding send on <code>c</code> completes, which happens
 before the <code>print</code>.
 </p>
 
@@ -453,7 +296,7 @@ crash, or do something else.)
 </p>
 
 <p class="rule">
-The <i>k</i>th receive from a channel with capacity <i>C</i> is synchronized before the completion of the <i>k</i>+<i>C</i>th send on that channel.
+The <i>k</i>th receive on a channel with capacity <i>C</i> happens before the <i>k</i>+<i>C</i>th send from that channel completes.
 </p>
 
 <p>
@@ -487,7 +330,7 @@ func main() {
 }
 </pre>
 
-<h3 id="locks">Locks</h3>
+<h3>Locks</h3>
 
 <p>
 The <code>sync</code> package implements two lock data types,
@@ -496,7 +339,7 @@ The <code>sync</code> package implements two lock data types,
 
 <p class="rule">
 For any <code>sync.Mutex</code> or <code>sync.RWMutex</code> variable <code>l</code> and <i>n</i> &lt; <i>m</i>,
-call <i>n</i> of <code>l.Unlock()</code> is synchronized before call <i>m</i> of <code>l.Lock()</code> returns.
+call <i>n</i> of <code>l.Unlock()</code> happens before call <i>m</i> of <code>l.Lock()</code> returns.
 </p>
 
 <p>
@@ -522,29 +365,19 @@ func main() {
 
 <p>
 is guaranteed to print <code>"hello, world"</code>.
-The first call to <code>l.Unlock()</code> (in <code>f</code>) is synchronized
+The first call to <code>l.Unlock()</code> (in <code>f</code>) happens
 before the second call to <code>l.Lock()</code> (in <code>main</code>) returns,
-which is sequenced before the <code>print</code>.
+which happens before the <code>print</code>.
 </p>
 
 <p class="rule">
 For any call to <code>l.RLock</code> on a <code>sync.RWMutex</code> variable <code>l</code>,
-there is an <i>n</i> such that the <i>n</i>th call to <code>l.Unlock</code>
-is synchronized before the return from <code>l.RLock</code>,
-and the matching call to <code>l.RUnlock</code> is synchronized before the return from call <i>n</i>+1 to <code>l.Lock</code>.
+there is an <i>n</i> such that the <code>l.RLock</code> happens (returns) after call <i>n</i> to
+<code>l.Unlock</code> and the matching <code>l.RUnlock</code> happens
+before call <i>n</i>+1 to <code>l.Lock</code>.
 </p>
 
-<p class="rule">
-A successful call to <code>l.TryLock</code> (or <code>l.TryRLock</code>)
-is equivalent to a call to <code>l.Lock</code> (or <code>l.RLock</code>).
-An unsuccessful call has no synchronizing effect at all.
-As far as the memory model is concerned,
-<code>l.TryLock</code> (or <code>l.TryRLock</code>)
-may be considered to be able to return false
-even when the mutex <i>l</i> is unlocked.
-</p>
-
-<h3 id="once">Once</h3>
+<h3>Once</h3>
 
 <p>
 The <code>sync</code> package provides a safe mechanism for
@@ -556,8 +389,7 @@ until <code>f()</code> has returned.
 </p>
 
 <p class="rule">
-The completion of a single call of <code>f()</code> from <code>once.Do(f)</code>
-is synchronized before the return of any call of <code>once.Do(f)</code>.
+A single call of <code>f()</code> from <code>once.Do(f)</code> happens (returns) before any call of <code>once.Do(f)</code> returns.
 </p>
 
 <p>
@@ -592,60 +424,13 @@ The result will be that <code>"hello, world"</code> will be printed
 twice.
 </p>
 
-<h3 id="atomic">Atomic Values</h3>
+<h2>Incorrect synchronization</h2>
 
 <p>
-The APIs in the <a href="/pkg/sync/atomic/"><code>sync/atomic</code></a>
-package are collectively “atomic operations”
-that can be used to synchronize the execution of different goroutines.
-If the effect of an atomic operation <i>A</i> is observed by atomic operation <i>B</i>,
-then <i>A</i> is synchronized before <i>B</i>.
-All the atomic operations executed in a program behave as though executed
-in some sequentially consistent order.
-</p>
-
-<p>
-The preceding definition has the same semantics as C++’s sequentially consistent atomics
-and Java’s <code>volatile</code> variables.
-</p>
-
-<h3 id="finalizer">Finalizers</h3>
-
-<p>
-The <a href="/pkg/runtime/"><code>runtime</code></a> package provides
-a <code>SetFinalizer</code> function that adds a finalizer to be called when
-a particular object is no longer reachable by the program.
-A call to <code>SetFinalizer(x, f)</code> is synchronized before the finalization call <code>f(x)</code>.
-</p>
-
-<h3 id="more">Additional Mechanisms</h3>
-
-<p>
-The <code>sync</code> package provides additional synchronization abstractions,
-including <a href="/pkg/sync/#Cond">condition variables</a>,
-<a href="/pkg/sync/#Map">lock-free maps</a>,
-<a href="/pkg/sync/#Pool">allocation pools</a>,
-and
-<a href="/pkg/sync/#WaitGroup">wait groups</a>.
-The documentation for each of these specifies the guarantees it
-makes concerning synchronization.
-</p>
-
-<p>
-Other packages that provide synchronization abstractions
-should document the guarantees they make too.
-</p>
-
-
-<h2 id="badsync">Incorrect synchronization</h2>
-
-<p>
-Programs with races are incorrect and
-can exhibit non-sequentially consistent executions.
-In particular, note that a read <i>r</i> may observe the value written by any write <i>w</i>
-that executes concurrently with <i>r</i>.
-Even if this occurs, it does not imply that reads happening after <i>r</i>
-will observe writes that happened before <i>w</i>.
+Note that a read <span class="event">r</span> may observe the value written by a write <span class="event">w</span>
+that happens concurrently with <span class="event">r</span>.
+Even if this occurs, it does not imply that reads happening after <span class="event">r</span>
+will observe writes that happened before <span class="event">w</span>.
 </p>
 
 <p>
@@ -781,197 +566,3 @@ value for <code>g.msg</code>.
 In all these examples, the solution is the same:
 use explicit synchronization.
 </p>
-
-<h2 id="badcompiler">Incorrect compilation</h2>
-
-<p>
-The Go memory model restricts compiler optimizations as much as it does Go programs.
-Some compiler optimizations that would be valid in single-threaded programs are not valid in all Go programs.
-In particular, a compiler must not introduce writes that do not exist in the original program,
-it must not allow a single read to observe multiple values,
-and it must not allow a single write to write multiple values.
-</p>
-
-<p>
-All the following examples assume that `*p` and `*q` refer to
-memory locations accessible to multiple goroutines.
-</p>
-
-<p>
-Not introducing data races into race-free programs means not moving
-writes out of conditional statements in which they appear.
-For example, a compiler must not invert the conditional in this program:
-</p>
-
-<pre>
-*p = 1
-if cond {
-	*p = 2
-}
-</pre>
-
-<p>
-That is, the compiler must not rewrite the program into this one:
-</p>
-
-<pre>
-*p = 2
-if !cond {
-	*p = 1
-}
-</pre>
-
-<p>
-If <code>cond</code> is false and another goroutine is reading <code>*p</code>,
-then in the original program, the other goroutine can only observe any prior value of <code>*p</code> and <code>1</code>.
-In the rewritten program, the other goroutine can observe <code>2</code>, which was previously impossible.
-</p>
-
-<p>
-Not introducing data races also means not assuming that loops terminate.
-For example, a compiler must in general not move the accesses to <code>*p</code> or <code>*q</code>
-ahead of the loop in this program:
-</p>
-
-<pre>
-n := 0
-for e := list; e != nil; e = e.next {
-	n++
-}
-i := *p
-*q = 1
-</pre>
-
-<p>
-If <code>list</code> pointed to a cyclic list,
-then the original program would never access <code>*p</code> or <code>*q</code>,
-but the rewritten program would.
-(Moving `*p` ahead would be safe if the compiler can prove `*p` will not panic;
-moving `*q` ahead would also require the compiler proving that no other
-goroutine can access `*q`.)
-</p>
-
-<p>
-Not introducing data races also means not assuming that called functions
-always return or are free of synchronization operations.
-For example, a compiler must not move the accesses to <code>*p</code> or <code>*q</code>
-ahead of the function call in this program
-(at least not without direct knowledge of the precise behavior of <code>f</code>):
-</p>
-
-<pre>
-f()
-i := *p
-*q = 1
-</pre>
-
-<p>
-If the call never returned, then once again the original program
-would never access <code>*p</code> or <code>*q</code>, but the rewritten program would.
-And if the call contained synchronizing operations, then the original program
-could establish happens before edges preceding the accesses
-to <code>*p</code> and <code>*q</code>, but the rewritten program would not.
-</p>
-
-<p>
-Not allowing a single read to observe multiple values means
-not reloading local variables from shared memory.
-For example, a compiler must not discard <code>i</code> and reload it
-a second time from <code>*p</code> in this program:
-</p>
-
-<pre>
-i := *p
-if i &lt; 0 || i &gt;= len(funcs) {
-	panic("invalid function index")
-}
-... complex code ...
-// compiler must NOT reload i = *p here
-funcs[i]()
-</pre>
-
-<p>
-If the complex code needs many registers, a compiler for single-threaded programs
-could discard <code>i</code> without saving a copy and then reload
-<code>i = *p</code> just before
-<code>funcs[i]()</code>.
-A Go compiler must not, because the value of <code>*p</code> may have changed.
-(Instead, the compiler could spill <code>i</code> to the stack.)
-</p>
-
-<p>
-Not allowing a single write to write multiple values also means not using
-the memory where a local variable will be written as temporary storage before the write.
-For example, a compiler must not use <code>*p</code> as temporary storage in this program:
-</p>
-
-<pre>
-*p = i + *p/2
-</pre>
-
-<p>
-That is, it must not rewrite the program into this one:
-</p>
-
-<pre>
-*p /= 2
-*p += i
-</pre>
-
-<p>
-If <code>i</code> and <code>*p</code> start equal to 2,
-the original code does <code>*p = 3</code>,
-so a racing thread can read only 2 or 3 from <code>*p</code>.
-The rewritten code does <code>*p = 1</code> and then <code>*p = 3</code>,
-allowing a racing thread to read 1 as well.
-</p>
-
-<p>
-Note that all these optimizations are permitted in C/C++ compilers:
-a Go compiler sharing a back end with a C/C++ compiler must take care
-to disable optimizations that are invalid for Go.
-</p>
-
-<p>
-Note that the prohibition on introducing data races
-does not apply if the compiler can prove that the races
-do not affect correct execution on the target platform.
-For example, on essentially all CPUs, it is valid to rewrite
-</p>
-
-<pre>
-n := 0
-for i := 0; i < m; i++ {
-	n += *shared
-}
-</pre>
-
-into:
-
-<pre>
-n := 0
-local := *shared
-for i := 0; i < m; i++ {
-	n += local
-}
-</pre>
-
-<p>
-provided it can be proved that <code>*shared</code> will not fault on access,
-because the potential added read will not affect any existing concurrent reads or writes.
-On the other hand, the rewrite would not be valid in a source-to-source translator.
-</p>
-
-<h2 id="conclusion">Conclusion</h2>
-
-<p>
-Go programmers writing data-race-free programs can rely on
-sequentially consistent execution of those programs,
-just as in essentially all other modern programming languages.
-</p>
-
-<p>
-When it comes to programs with races,
-both programmers and compilers should remember the advice:
-don't be clever.
-</p>

doc/godebug.md

@@ -1,526 +0,0 @@
----
-title: "Go, Backwards Compatibility, and GODEBUG"
-layout: article
----
-
-<!--
-This document is kept in the Go repo, not x/website,
-because it documents the full list of known GODEBUG settings,
-which are tied to a specific release.
--->
-
-## Introduction {#intro}
-
-Go's emphasis on backwards compatibility is one of its key strengths.
-There are, however, times when we cannot maintain complete compatibility.
-If code depends on buggy (including insecure) behavior,
-then fixing the bug will break that code.
-New features can also have similar impacts:
-enabling the HTTP/2 use by the HTTP client broke programs
-connecting to servers with buggy HTTP/2 implementations.
-These kinds of changes are unavoidable and
-[permitted by the Go 1 compatibility rules](/doc/go1compat).
-Even so, Go provides a mechanism called GODEBUG to
-reduce the impact such changes have on Go developers
-using newer toolchains to compile old code.
-
-A GODEBUG setting is a `key=value` pair
-that controls the execution of certain parts of a Go program.
-The environment variable `GODEBUG`
-can hold a comma-separated list of these settings.
-For example, if a Go program is running in an environment that contains
-
-	GODEBUG=http2client=0,http2server=0
-
-then that Go program will disable the use of HTTP/2 by default in both
-the HTTP client and the HTTP server.
-Unrecognized settings in the `GODEBUG` environment variable are ignored.
-It is also possible to set the default `GODEBUG` for a given program
-(discussed below).
-
-When preparing any change that is permitted by Go 1 compatibility
-but may nonetheless break some existing programs,
-we first engineer the change to keep as many existing programs working as possible.
-For the remaining programs,
-we define a new GODEBUG setting that
-allows individual programs to opt back in to the old behavior.
-A GODEBUG setting may not be added if doing so is infeasible,
-but that should be extremely rare.
-
-GODEBUG settings added for compatibility will be maintained
-for a minimum of two years (four Go releases).
-Some, such as `http2client` and `http2server`,
-will be maintained much longer, even indefinitely.
-
-When possible, each GODEBUG setting has an associated
-[runtime/metrics](/pkg/runtime/metrics/) counter
-named `/godebug/non-default-behavior/<name>:events`
-that counts the number of times a particular program's
-behavior has changed based on a non-default value
-for that setting.
-For example, when `GODEBUG=http2client=0` is set,
-`/godebug/non-default-behavior/http2client:events`
-counts the number of HTTP transports that the program
-has configured without HTTP/2 support.
-
-## Default GODEBUG Values {#default}
-
-When a GODEBUG setting is not listed in the environment variable,
-its value is derived from three sources:
-the defaults for the Go toolchain used to build the program,
-amended to match the Go version listed in `go.mod`,
-and then overridden by explicit `//go:debug` lines in the program.
-
-The [GODEBUG History](#history) gives the exact defaults for each Go toolchain version.
-For example, Go 1.21 introduces the `panicnil` setting,
-controlling whether `panic(nil)` is allowed;
-it defaults to `panicnil=0`, making `panic(nil)` a run-time error.
-Using `panicnil=1` restores the behavior of Go 1.20 and earlier.
-
-When compiling a work module or workspace that declares
-an older Go version, the Go toolchain amends its defaults
-to match that older Go version as closely as possible.
-For example, when a Go 1.21 toolchain compiles a program,
-if the work module's `go.mod` or the workspace's `go.work`
-says `go` `1.20`, then the program defaults to `panicnil=1`,
-matching Go 1.20 instead of Go 1.21.
-
-Because this method of setting GODEBUG defaults was introduced only in Go 1.21,
-programs listing versions of Go earlier than Go 1.20 are configured to match Go 1.20,
-not the older version.
-
-To override these defaults, starting in Go 1.23, the work module's `go.mod`
-or the workspace's `go.work` can list one or more `godebug` lines:
-
-	godebug (
-		default=go1.21
-		panicnil=1
-		asynctimerchan=0
-	)
-
-The special key `default` indicates a Go version to take unspecified
-settings from. This allows setting the GODEBUG defaults separately
-from the Go language version in the module.
-In this example, the program is asking for Go 1.21 semantics and
-then asking for the old pre-Go 1.21 `panic(nil)` behavior and the
-new Go 1.23 `asynctimerchan=0` behavior.
-
-Only the work module's `go.mod` is consulted for `godebug` directives.
-Any directives in required dependency modules are ignored.
-It is an error to list a `godebug` with an unrecognized setting.
-(Toolchains older than Go 1.23 reject all `godebug` lines, since they do not
-understand `godebug` at all.) When a workspace is in use, `godebug`
-directives in `go.mod` files are ignored, and `go.work` will be consulted
-for `godebug` directives instead.
-
-The defaults from the `go` and `godebug` lines apply to all main
-packages that are built. For more fine-grained control,
-starting in Go 1.21, a main package's source files
-can include one or more `//go:debug` directives at the top of the file
-(preceding the `package` statement).
-The `godebug` lines in the previous example would be written:
-
-	//go:debug default=go1.21
-	//go:debug panicnil=1
-	//go:debug asynctimerchan=0
-
-Starting in Go 1.21, the Go toolchain treats a `//go:debug` directive
-with an unrecognized GODEBUG setting as an invalid program.
-Programs with more than one `//go:debug` line for a given setting
-are also treated as invalid.
-(Older toolchains ignore `//go:debug` directives entirely.)
-
-The defaults that will be compiled into a main package
-are reported by the command:
-
-{{raw `
-	go list -f '{{.DefaultGODEBUG}}' my/main/package
-`}}
-
-Only differences from the base Go toolchain defaults are reported.
-
-When testing a package, `//go:debug` lines in the `*_test.go`
-files are treated as directives for the test's main package.
-In any other context, `//go:debug` lines are ignored by the toolchain;
-`go` `vet` reports such lines as misplaced.
-
-## GODEBUG History {#history}
-
-This section documents the GODEBUG settings introduced and removed in each major Go release
-for compatibility reasons.
-Packages or programs may define additional settings for internal debugging purposes;
-for example,
-see the [runtime documentation](/pkg/runtime#hdr-Environment_Variables)
-and the [go command documentation](/cmd/go#hdr-Build_and_test_caching).
-
-### Go 1.26
-
-Go 1.26 added a new `httpcookiemaxnum` setting that controls the maximum number
-of cookies that net/http will accept when parsing HTTP headers. If the number of
-cookie in a header exceeds the number set in `httpcookiemaxnum`, cookie parsing
-will fail early. The default value is `httpcookiemaxnum=3000`. Setting
-`httpcookiemaxnum=0` will allow the cookie parsing to accept an indefinite
-number of cookies. To avoid denial of service attacks, this setting and default
-was backported to Go 1.25.2 and Go 1.24.8.
-
-Go 1.26 added a new `urlmaxqueryparams` setting that controls the maximum number
-of query parameters that net/url will accept when parsing a URL-encoded query string.
-If the number of parameters exceeds the number set in `urlmaxqueryparams`,
-parsing will fail early. The default value is `urlmaxqueryparams=10000`.
-Setting `urlmaxqueryparams=0` disables the limit. To avoid denial of service
-attacks, this setting and default was backported to Go 1.25.6 and Go 1.24.12.
-
-Go 1.26 added a new `urlstrictcolons` setting that controls whether `net/url.Parse`
-allows malformed hostnames containing colons outside of a bracketed IPv6 address.
-The default `urlstrictcolons=1` rejects URLs such as `http://localhost:1:2` or `http://::1/`.
-Colons are permitted as part of a bracketed IPv6 address, such as `http://[::1]/`.
-
-Go 1.26 enabled two additional post-quantum key exchange mechanisms:
-SecP256r1MLKEM768 and SecP384r1MLKEM1024. The default can be reverted using the
-[`tlssecpmlkem` setting](/pkg/crypto/tls/#Config.CurvePreferences).
-
-Go 1.26 added a new `tracebacklabels` setting that controls the inclusion of
-goroutine labels set through the the `runtime/pprof` package. Setting `tracebacklabels=1`
-includes these key/value pairs in the goroutine status header of runtime
-tracebacks and debug=2 runtime/pprof stack dumps. This format may change in the future.
-(see go.dev/issue/76349)
-
-Go 1.26 added a new `cryptocustomrand` setting that controls whether most crypto/...
-APIs ignore the random `io.Reader` parameter. For Go 1.26, it defaults
-to `cryptocustomrand=0`, ignoring the random parameters. Using `cryptocustomrand=1`
-reverts to the pre-Go 1.26 behavior.
-
-### Go 1.25
-
-Go 1.25 added a new `decoratemappings` setting that controls whether the Go
-runtime annotates OS anonymous memory mappings with context about their
-purpose. These annotations appear in /proc/self/maps and /proc/self/smaps as
-"[anon: Go: ...]". This setting is only used on Linux. For Go 1.25, it defaults
-to `decoratemappings=1`, enabling annotations. Using `decoratemappings=0`
-reverts to the pre-Go 1.25 behavior. This setting is fixed at program startup
-time, and can't be modified by changing the `GODEBUG` environment variable
-after the program starts.
-
-Go 1.25 added a new `embedfollowsymlinks` setting that controls whether the
-Go command will follow symlinks to regular files embedding files.
-The default value `embedfollowsymlinks=0` does not allow following
-symlinks. `embedfollowsymlinks=1` will allow following symlinks.
-
-Go 1.25 added a new `containermaxprocs` setting that controls whether the Go
-runtime will consider cgroup CPU limits when setting the default GOMAXPROCS.
-The default value `containermaxprocs=1` will use cgroup limits in addition to
-the total logical CPU count and CPU affinity. `containermaxprocs=0` will
-disable consideration of cgroup limits. This setting only affects Linux.
-
-Go 1.25 added a new `updatemaxprocs` setting that controls whether the Go
-runtime will periodically update GOMAXPROCS for new CPU affinity or cgroup
-limits. The default value `updatemaxprocs=1` will enable periodic updates.
-`updatemaxprocs=0` will disable periodic updates.
-
-Go 1.25 disabled SHA-1 signature algorithms in TLS 1.2 according to RFC 9155.
-The default can be reverted using the `tlssha1=1` setting.
-
-Go 1.25 switched to SHA-256 to fill in missing SubjectKeyId in
-crypto/x509.CreateCertificate. The setting `x509sha256skid=0` reverts to SHA-1.
-
-Go 1.25 corrected the semantics of contention reports for runtime-internal locks,
-and so removed the [`runtimecontentionstacks` setting](/pkg/runtime#hdr-Environment_Variables).
-
-Go 1.25 (starting with Go 1.25 RC 2) disabled build information stamping when
-multiple VCS are detected due to concerns around VCS injection attacks. This
-behavior and setting was backported to Go 1.24.5 and Go 1.23.11. This behavior
-can be renabled with the setting `allowmultiplevcs=1`.
-
-### Go 1.24
-
-Go 1.24 added a new `fips140` setting that controls whether the Go
-Cryptographic Module operates in FIPS 140-3 mode.
-The possible values are:
-- "off": no special support for FIPS 140-3 mode. This is the default.
-- "on": the Go Cryptographic Module operates in FIPS 140-3 mode.
-- "only": like "on", but cryptographic algorithms not approved by
-  FIPS 140-3 return an error or panic.
-For more information, see [FIPS 140-3 Compliance](/doc/security/fips140).
-This setting is fixed at program startup time, and can't be modified
-by changing the `GODEBUG` environment variable after the program starts.
-
-Go 1.24 changed the global [`math/rand.Seed`](/pkg/math/rand/#Seed) to be a
-no-op. This behavior is controlled by the `randseednop` setting.
-For Go 1.24 it defaults to `randseednop=1`.
-Using `randseednop=0` reverts to the pre-Go 1.24 behavior.
-
-Go 1.24 added new values for the `multipathtcp` setting.
-The possible values for `multipathtcp` are now:
-- "0": disable MPTCP on dialers and listeners by default
-- "1": enable MPTCP on dialers and listeners by default
-- "2": enable MPTCP on listeners only by default
-- "3": enable MPTCP on dialers only by default
-
-For Go 1.24, it now defaults to multipathtcp="2", thus
-enabled by default on listeners. Using multipathtcp="0" reverts to the
-pre-Go 1.24 behavior.
-
-Go 1.24 changed the behavior of `go test -json` to emit build errors as JSON
-instead of text.
-These new JSON events are distinguished by new `Action` values,
-but can still cause problems with CI systems that aren't robust to these events.
-This behavior can be controlled with the `gotestjsonbuildtext` setting.
-Using `gotestjsonbuildtext=1` restores the 1.23 behavior.
-This setting will be removed in a future release, Go 1.28 at the earliest.
-
-Go 1.24 changed [`crypto/rsa`](/pkg/crypto/rsa) to require RSA keys to be at
-least 1024 bits. This behavior can be controlled with the `rsa1024min` setting.
-Using `rsa1024min=0` restores the Go 1.23 behavior.
-
-Go 1.24 introduced a mechanism for enabling platform specific Data Independent
-Timing (DIT) modes in the [`crypto/subtle`](/pkg/crypto/subtle) package. This
-mode can be enabled for an entire program with the `dataindependenttiming` setting.
-For Go 1.24 it defaults to `dataindependenttiming=0`. There is no change in default
-behavior from Go 1.23 when `dataindependenttiming` is unset.
-Using `dataindependenttiming=1` enables the DIT mode for the entire Go program.
-When enabled, DIT will be enabled when calling into C from Go. When enabled,
-calling into Go code from C will enable DIT, and disable it before returning to
-C if it was not enabled when Go code was entered.
-This currently only affects arm64 programs. For all other platforms it is a no-op.
-
-Go 1.24 removed the `x509sha1` setting.  `crypto/x509` no longer supports verifying
-signatures on certificates that use SHA-1 based signature algorithms.
-
-Go 1.24 changes the default value of the [`x509usepolicies`
-setting.](/pkg/crypto/x509/#CreateCertificate) from `0` to `1`. When marshalling
-certificates, policies are now taken from the
-[`Certificate.Policies`](/pkg/crypto/x509/#Certificate.Policies) field rather
-than the
-[`Certificate.PolicyIdentifiers`](/pkg/crypto/x509/#Certificate.PolicyIdentifiers)
-field by default.
-
-Go 1.24 enabled the post-quantum key exchange mechanism
-X25519MLKEM768 by default. The default can be reverted using the
-[`tlsmlkem` setting](/pkg/crypto/tls/#Config.CurvePreferences).
-This can be useful when dealing with buggy TLS servers that do not handle large records correctly,
-causing a timeout during the handshake (see [TLS post-quantum TL;DR fail](https://tldr.fail/)).
-Go 1.24 also removed X25519Kyber768Draft00 and the Go 1.23 `tlskyber` setting.
-
-Go 1.24 made [`ParsePKCS1PrivateKey`](/pkg/crypto/x509/#ParsePKCS1PrivateKey)
-use and validate the CRT parameters in the encoded private key. This behavior
-can be controlled with the `x509rsacrt` setting. Using `x509rsacrt=0` restores
-the Go 1.23 behavior.
-
-### Go 1.23
-
-Go 1.23 changed the channels created by package time to be unbuffered
-(synchronous), which makes correct use of the [`Timer.Stop`](/pkg/time/#Timer.Stop)
-and [`Timer.Reset`](/pkg/time/#Timer.Reset) method results much easier.
-The [`asynctimerchan` setting](/pkg/time/#NewTimer) disables this change.
-There are no runtime metrics for this change,
-This setting will be removed in Go 1.27.
-
-Go 1.23 changed the mode bits reported by [`os.Lstat`](/pkg/os#Lstat) and [`os.Stat`](/pkg/os#Stat)
-for reparse points, which can be controlled with the `winsymlink` setting.
-As of Go 1.23 (`winsymlink=1`), mount points no longer have [`os.ModeSymlink`](/pkg/os#ModeSymlink)
-set, and reparse points that are not symlinks, Unix sockets, or dedup files now
-always have [`os.ModeIrregular`](/pkg/os#ModeIrregular) set. As a result of these changes,
-[`filepath.EvalSymlinks`](/pkg/path/filepath#EvalSymlinks) no longer evaluates
-mount points, which was a source of many inconsistencies and bugs.
-At previous versions (`winsymlink=0`), mount points are treated as symlinks,
-and other reparse points with non-default [`os.ModeType`](/pkg/os#ModeType) bits
-(such as [`os.ModeDir`](/pkg/os#ModeDir)) do not have the `ModeIrregular` bit set.
-
-Go 1.23 changed [`os.Readlink`](/pkg/os#Readlink) and [`filepath.EvalSymlinks`](/pkg/path/filepath#EvalSymlinks)
-to avoid trying to normalize volumes to drive letters, which was not always even possible.
-This behavior is controlled by the `winreadlinkvolume` setting.
-For Go 1.23, it defaults to `winreadlinkvolume=1`.
-Previous versions default to `winreadlinkvolume=0`.
-
-Go 1.23 enabled the experimental post-quantum key exchange mechanism
-X25519Kyber768Draft00 by default. The default can be reverted using the
-[`tlskyber` setting](/pkg/crypto/tls/#Config.CurvePreferences).
-This can be useful when dealing with buggy TLS servers that do not handle large records correctly,
-causing a timeout during the handshake (see [TLS post-quantum TL;DR fail](https://tldr.fail/)).
-
-Go 1.23 changed the behavior of
-[crypto/x509.ParseCertificate](/pkg/crypto/x509/#ParseCertificate) to reject
-serial numbers that are negative. This change can be reverted with
-the [`x509negativeserial` setting](/pkg/crypto/x509/#ParseCertificate).
-
-Go 1.23 re-enabled support in html/template for ECMAScript 6 template literals by default.
-The [`jstmpllitinterp` setting](/pkg/html/template#hdr-Security_Model) no longer has
-any effect.
-
-Go 1.23 changed the default TLS cipher suites used by clients and servers when
-not explicitly configured, removing 3DES cipher suites. The default can be reverted
-using the [`tls3des` setting](/pkg/crypto/tls/#Config.CipherSuites).
-This setting will be removed in Go 1.27.
-
-Go 1.23 changed the behavior of [`tls.X509KeyPair`](/pkg/crypto/tls#X509KeyPair)
-and [`tls.LoadX509KeyPair`](/pkg/crypto/tls#LoadX509KeyPair) to populate the
-Leaf field of the returned [`tls.Certificate`](/pkg/crypto/tls#Certificate).
-This behavior is controlled by the `x509keypairleaf` setting. For Go 1.23, it
-defaults to `x509keypairleaf=1`. Previous versions default to
-`x509keypairleaf=0`.
-This setting will be removed in Go 1.27.
-
-Go 1.23 changed
-[`net/http.ServeContent`](/pkg/net/http#ServeContent),
-[`net/http.ServeFile`](/pkg/net/http#ServeFile), and
-[`net/http.ServeFS`](/pkg/net/http#ServeFS) to
-remove Cache-Control, Content-Encoding, Etag, and Last-Modified headers
-when serving an error. This behavior is controlled by
-the [`httpservecontentkeepheaders` setting](/pkg/net/http#ServeContent).
-Using `httpservecontentkeepheaders=1` restores the pre-Go 1.23 behavior.
-
-### Go 1.22
-
-Go 1.22 adds a configurable limit to control the maximum acceptable RSA key size
-that can be used in TLS handshakes, controlled by the [`tlsmaxrsasize` setting](/pkg/crypto/tls#Conn.Handshake).
-The default is tlsmaxrsasize=8192, limiting RSA to 8192-bit keys. To avoid
-denial of service attacks, this setting and default was backported to Go
-1.19.13, Go 1.20.8, and Go 1.21.1.
-
-Go 1.22 made it an error for a request or response read by a net/http
-client or server to have an empty Content-Length header.
-This behavior is controlled by the `httplaxcontentlength` setting.
-
-Go 1.22 changed the behavior of ServeMux to accept extended
-patterns and unescape both patterns and request paths by segment.
-This behavior can be controlled by the
-[`httpmuxgo121` setting](/pkg/net/http/#ServeMux).
-
-Go 1.22 added the [Alias type](/pkg/go/types#Alias) to [go/types](/pkg/go/types)
-for the explicit representation of [type aliases](/ref/spec#Type_declarations).
-Whether the type checker produces `Alias` types or not is controlled by the
-[`gotypesalias` setting](/pkg/go/types#Alias).
-For Go 1.22 it defaults to `gotypesalias=0`.
-For Go 1.23, `gotypesalias=1` will become the default.
-This setting will be removed in Go 1.27.
-
-Go 1.22 changed the default minimum TLS version supported by both servers
-and clients to TLS 1.2. The default can be reverted to TLS 1.0 using the
-[`tls10server` setting](/pkg/crypto/tls/#Config).
-This setting will be removed in Go 1.27.
-
-Go 1.22 changed the default TLS cipher suites used by clients and servers when
-not explicitly configured, removing the cipher suites which used RSA based key
-exchange. The default can be reverted using the [`tlsrsakex` setting](/pkg/crypto/tls/#Config).
-This setting will be removed in Go 1.27.
-
-Go 1.22 disabled
-[`ConnectionState.ExportKeyingMaterial`](/pkg/crypto/tls/#ConnectionState.ExportKeyingMaterial)
-when the connection supports neither TLS 1.3 nor Extended Master Secret
-(implemented in Go 1.21). It can be reenabled with the [`tlsunsafeekm`
-setting](/pkg/crypto/tls/#ConnectionState.ExportKeyingMaterial).
-This setting will be removed in Go 1.27.
-
-Go 1.22 changed how the runtime interacts with transparent huge pages on Linux.
-In particular, a common default Linux kernel configuration can result in
-significant memory overheads, and Go 1.22 no longer works around this default.
-To work around this issue without adjusting kernel settings, transparent huge
-pages can be disabled for Go memory with the
-[`disablethp` setting](/pkg/runtime#hdr-Environment_Variables).
-This behavior was backported to Go 1.21.1, but the setting is only available
-starting with Go 1.21.6.
-This setting may be removed in a future release, and users impacted by this issue
-should adjust their Linux configuration according to the recommendations in the
-[GC guide](/doc/gc-guide#Linux_transparent_huge_pages), or switch to a Linux
-distribution that disables transparent huge pages altogether.
-
-Go 1.22 added contention on runtime-internal locks to the [`mutex`
-profile](/pkg/runtime/pprof#Profile). Contention on these locks is always
-reported at `runtime._LostContendedRuntimeLock`. Complete stack traces of
-runtime locks can be enabled with the [`runtimecontentionstacks`
-setting](/pkg/runtime#hdr-Environment_Variables). These stack traces have
-non-standard semantics, see setting documentation for details.
-
-Go 1.22 added a new [`crypto/x509.Certificate`](/pkg/crypto/x509/#Certificate)
-field, [`Policies`](/pkg/crypto/x509/#Certificate.Policies), which supports
-certificate policy OIDs with components larger than 31 bits. By default this
-field is only used during parsing, when it is populated with policy OIDs, but
-not used during marshaling. It can be used to marshal these larger OIDs, instead
-of the existing PolicyIdentifiers field, by using the
-[`x509usepolicies` setting](/pkg/crypto/x509/#CreateCertificate).
-
-
-### Go 1.21
-
-Go 1.21 made it a run-time error to call `panic` with a nil interface value,
-controlled by the [`panicnil` setting](/pkg/builtin/#panic).
-
-Go 1.21 made it an error for html/template actions to appear inside of an ECMAScript 6
-template literal, controlled by the
-[`jstmpllitinterp` setting](/pkg/html/template#hdr-Security_Model).
-This behavior was backported to Go 1.19.8+ and Go 1.20.3+.
-
-Go 1.21 introduced a limit on the maximum number of MIME headers and multipart
-forms, controlled by the
-[`multipartmaxheaders` and `multipartmaxparts` settings](/pkg/mime/multipart#hdr-Limits)
-respectively.
-This behavior was backported to Go 1.19.8+ and Go 1.20.3+.
-
-Go 1.21 adds the support of Multipath TCP but it is only used if the application
-explicitly asked for it. This behavior can be controlled by the
-[`multipathtcp` setting](/pkg/net#Dialer.SetMultipathTCP).
-
-There is no plan to remove any of these settings.
-
-### Go 1.20
-
-Go 1.20 introduced support for rejecting insecure paths in tar and zip archives,
-controlled by the [`tarinsecurepath` setting](/pkg/archive/tar/#Reader.Next)
-and the [`zipinsecurepath` setting](/pkg/archive/zip/#NewReader).
-These default to `tarinsecurepath=1` and `zipinsecurepath=1`,
-preserving the behavior of earlier versions of Go.
-A future version of Go may change the defaults to
-`tarinsecurepath=0` and `zipinsecurepath=0`.
-
-Go 1.20 introduced automatic seeding of the
-[`math/rand`](/pkg/math/rand) global random number generator,
-controlled by the [`randautoseed` setting](/pkg/math/rand/#Seed).
-
-Go 1.20 introduced the concept of fallback roots for use during certificate verification,
-controlled by the [`x509usefallbackroots` setting](/pkg/crypto/x509/#SetFallbackRoots).
-
-Go 1.20 removed the preinstalled `.a` files for the standard library
-from the Go distribution.
-Installations now build and cache the standard library like
-packages in other modules.
-The [`installgoroot` setting](/cmd/go#hdr-Compile_and_install_packages_and_dependencies)
-restores the installation and use of preinstalled `.a` files.
-
-There is no plan to remove any of these settings.
-
-### Go 1.19
-
-Go 1.19 made it an error for path lookups to resolve to binaries in the current directory,
-controlled by the [`execerrdot` setting](/pkg/os/exec#hdr-Executables_in_the_current_directory).
-There is no plan to remove this setting.
-
-Go 1.19 started sending EDNS0 additional headers on DNS requests.
-This can reportedly break the DNS server provided on some routers,
-such as CenturyLink Zyxel C3000Z.
-This can be changed by the [`netedns0` setting](/pkg/net#hdr-Name_Resolution).
-This setting is available in Go 1.21.12, Go 1.22.5, Go 1.23, and later.
-There is no plan to remove this setting.
-
-### Go 1.18
-
-Go 1.18 removed support for SHA1 in most X.509 certificates,
-controlled by the [`x509sha1` setting](/pkg/crypto/x509#InsecureAlgorithmError).
-This setting was removed in Go 1.24.
-
-### Go 1.10
-
-Go 1.10 changed how build caching worked and added test caching, along
-with the [`gocacheverify`, `gocachehash`, and `gocachetest` settings](/cmd/go/#hdr-Build_and_test_caching).
-There is no plan to remove these settings.
-
-### Go 1.6
-
-Go 1.6 introduced transparent support for HTTP/2,
-controlled by the [`http2client`, `http2server`, and `http2debug` settings](/pkg/net/http/#hdr-HTTP_2).
-There is no plan to remove these settings.
-
-### Go 1.5
-
-Go 1.5 introduced a pure Go DNS resolver,
-controlled by the [`netdns` setting](/pkg/net/#hdr-Name_Resolution).
-There is no plan to remove this setting.

doc/initial/1-intro.md

@@ -1,8 +0,0 @@
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-## DRAFT RELEASE NOTES — Introduction to Go 1.N {#introduction}
-
-**Go 1.N is not yet released. These are work-in-progress release notes.
-Go 1.N is expected to be released in {Month} {Year}.**

doc/initial/2-language.md

@@ -1,3 +0,0 @@
-## Changes to the language {#language}
-
-

doc/initial/3-tools.md

@@ -1,6 +0,0 @@
-## Tools {#tools}
-
-### Go command {#go-command}
-
-### Cgo {#cgo}
-

doc/initial/4-runtime.md

@@ -1 +0,0 @@
-## Runtime {#runtime}

doc/initial/5-toolchain.md

@@ -1,7 +0,0 @@
-## Compiler {#compiler}
-
-## Assembler {#assembler}
-
-## Linker {#linker}
-
-

doc/initial/6-stdlib/0-heading.md

@@ -1,2 +0,0 @@
-## Standard library {#library}
-

doc/initial/6-stdlib/99-minor/0-heading.md

@@ -1 +0,0 @@
-### Minor changes to the library {#minor_library_changes}

doc/initial/6-stdlib/99-minor/README

@@ -1 +0,0 @@
-API changes and other small changes to the standard library go here.

doc/initial/7-ports.md

@@ -1,2 +0,0 @@
-## Ports {#ports}
-

doc/next/1-intro.md

@@ -1,8 +0,0 @@
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-## DRAFT RELEASE NOTES — Introduction to Go 1.27 {#introduction}
-
-**Go 1.27 is not yet released. These are work-in-progress release notes.
-Go 1.27 is expected to be released in August 2026.**

doc/next/2-language.md

@@ -1,3 +0,0 @@
-## Changes to the language {#language}
-
-

doc/next/3-tools.md

@@ -1,6 +0,0 @@
-## Tools {#tools}
-
-### Go command {#go-command}
-
-### Cgo {#cgo}
-

doc/next/4-runtime.md

@@ -1 +0,0 @@
-## Runtime {#runtime}

doc/next/5-toolchain.md

@@ -1,7 +0,0 @@
-## Compiler {#compiler}
-
-## Assembler {#assembler}
-
-## Linker {#linker}
-
-

doc/next/6-stdlib/0-heading.md

@@ -1,2 +0,0 @@
-## Standard library {#library}
-

doc/next/6-stdlib/99-minor/0-heading.md

@@ -1 +0,0 @@
-### Minor changes to the library {#minor_library_changes}

doc/next/6-stdlib/99-minor/README

@@ -1 +0,0 @@
-API changes and other small changes to the standard library go here.

doc/next/6-stdlib/99-minor/go/scanner/74958.md

@@ -1 +0,0 @@
-The scanner now allows retrieving the end position of a token via the new [Scanner.End] method.

doc/next/6-stdlib/99-minor/net/http/75500.md

@@ -1,4 +0,0 @@
-HTTP/2 server now accepts client priority signals, as defined in RFC 9218,
-allowing it to prioritize serving HTTP/2 streams with higher priority. If the
-old behavior is preferred, where streams are served in a round-robin manner
-regardless of priority, [Server.DisableClientPriority] can be set to `true`.

doc/next/6-stdlib/99-minor/unicode/77266.md

@@ -1,4 +0,0 @@
-The unicode package and associated support throughout the system has been upgraded from Unicode 15 to Unicode 17.
-See the [Unicode 16.0.0](https://www.unicode.org/versions/Unicode16.0.0/) and
-[Unicode 17.0.0](https://www.unicode.org/versions/Unicode17.0.0/)
-release notes for information about the changes.

doc/next/7-ports.md

@@ -1,8 +0,0 @@
-## Ports {#ports}
-
-### Darwin {#darwin}
-
-<!-- go.dev/issue/75836 -->
-As [announced](go1.26#darwin) in the Go 1.26 release notes,
-Go 1.27 requires macOS 13 Ventura or later;
-support for previous versions has been discontinued.

go.env

@@ -1,12 +0,0 @@
-# This file contains the initial defaults for go command configuration.
-# Values set by 'go env -w' and written to the user's go/env file override these.
-# The environment overrides everything else.
-
-# Use the Go module mirror and checksum database by default.
-# See https://proxy.golang.org for details.
-GOPROXY=https://proxy.golang.org,direct
-GOSUMDB=sum.golang.org
-
-# Automatically download newer toolchains as directed by go.mod files.
-# See https://go.dev/doc/toolchain for details.
-GOTOOLCHAIN=auto

lib/fips140/Makefile

@@ -1,46 +0,0 @@
-# Copyright 2024 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.
-
-# Rules for building and testing new FIPS snapshots.
-# For example:
-#
-#	make v1.2.3.zip
-#	make v1.2.3.test
-#
-# and then if changes are needed, check them into master
-# and run 'make v1.2.3.rm' and repeat.
-#
-# Note that once published a snapshot zip file should never
-# be modified. We record the sha256 hashes of the zip files
-# in fips140.sum, and the cmd/go/internal/fips140 test checks
-# that the zips match.
-#
-# When the zip file is finalized, run 'make updatesum' to update
-# fips140.sum.
-
-default:
-	@echo nothing to make
-
-# make v1.2.3.zip builds a v1.2.3.zip file
-# from the current origin/master.
-# copy and edit the 'go run' command by hand to use a different branch.
-v%.zip:
-	git fetch origin master
-	go run ../../src/cmd/go/internal/fips140/mkzip.go v$*
-
-# normally mkzip refuses to overwrite an existing zip file.
-# make v1.2.3.rm removes the zip file and unpacked
-# copy from the module cache.
-v%.rm:
-	rm -f v$*.zip
-	chmod -R u+w $$(go env GOMODCACHE)/golang.org/fips140@v$* 2>/dev/null || true
-	rm -rf $$(go env GOMODCACHE)/golang.org/fips140@v$*
-
-# make v1.2.3.test runs the crypto tests using that snapshot.
-v%.test:
-	GOFIPS140=v$* go test -short crypto...
-
-# make updatesum updates the fips140.sum file.
-updatesum:
-	go test cmd/go/internal/fips140 -update

lib/fips140/README.md

@@ -1,9 +0,0 @@
-This directory holds snapshots of the crypto/internal/fips140 tree
-that are being validated and certified for FIPS-140 use.
-The file x.txt (for example, inprocess.txt, certified.txt)
-defines the meaning of the FIPS version alias x, listing
-the exact version to use.
-
-The zip files are created by cmd/go/internal/fips140/mkzip.go.
-The fips140.sum file lists checksums for the zip files.
-See the Makefile for recipes.

lib/fips140/fips140.sum

@@ -1,13 +0,0 @@
-# SHA256 checksums of snapshot zip files in this directory.
-# These checksums are included in the FIPS security policy
-# (validation instructions sent to the lab) and MUST NOT CHANGE.
-# That is, the zip files themselves must not change.
-#
-# It is okay to add new zip files to the list, and it is okay to
-# remove zip files from the list when they are removed from
-# this directory. To update this file:
-#
-#	go test cmd/go/internal/fips140 -update
-#
-v1.0.0-c2097c7c.zip daf3614e0406f67ae6323c902db3f953a1effb199142362a039e7526dfb9368b
-v1.26.0.zip 9b28f847fdf1db4a36cb2b2f8ec09443c039383f085630a03ecfaddf6db7ea23

lib/fips140/inprocess.txt

@@ -1 +0,0 @@
-v1.0.0-c2097c7c

lib/fips140/v1.0.0.txt

@@ -1 +0,0 @@
-v1.0.0-c2097c7c

lib/hg/goreposum.py

@@ -1,64 +0,0 @@
-# Copyright 2025 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.
-
-# Mercurial extension to add a 'goreposum' command that
-# computes a hash of a remote repo's tag state.
-# Tag definitions can come from the .hgtags file stored in
-# any head of any branch, and the server protocol does not
-# expose the tags directly. However, the protocol does expose
-# the hashes of all the branch heads, so we can use a hash of
-# all those branch names and heads as a conservative snapshot
-# of the entire remote repo state, and use that as the tag sum.
-# Any change on the server then invalidates the tag sum,
-# even if it didn't have anything to do with tags, but at least
-# we will avoid re-cloning a server when there have been no
-# changes at all.
-#
-# Separately, this extension also adds a 'golookup' command that
-# returns the hash of a specific reference, like 'default' or a tag.
-# And golookup of a hash confirms that it still exists on the server.
-# We can use that to revalidate that specific versions still exist and
-# have the same meaning they did the last time we checked.
-#
-# Usage:
-#
-#	hg --config "extensions.goreposum=$GOROOT/lib/hg/goreposum.py" goreposum REPOURL
-
-import base64, hashlib, sys
-from mercurial import registrar, ui, hg, node
-from mercurial.i18n import _
-cmdtable = {}
-command = registrar.command(cmdtable)
-@command(b'goreposum', [], _('url'), norepo=True)
-def goreposum(ui, url):
-  """
-  goreposum computes a checksum of all the named state in the remote repo.
-  It hashes together all the branch names and hashes
-  and then all the bookmark names and hashes.
-  Tags are stored in .hgtags files in any of the branches,
-  so the branch metadata includes the tags as well.
-  """
-  h = hashlib.sha256()
-  peer = hg.peer(ui, {}, url)
-  for name, revs in peer.branchmap().items():
-    h.update(name)
-    for r in revs:
-      h.update(b' ')
-      h.update(r)
-    h.update(b'\n')
-  if (b'bookmarks' in peer.listkeys(b'namespaces')):
-    for name, rev in peer.listkeys(b'bookmarks').items():
-      h.update(name)
-      h.update(b'=')
-      h.update(rev)
-      h.update(b'\n')
-  print('r1:'+base64.standard_b64encode(h.digest()).decode('utf-8'))
-
-@command(b'golookup', [], _('url rev'), norepo=True)
-def golookup(ui, url, rev):
-  """
-  golookup looks up a single identifier in the repo,
-  printing its hash.
-  """
-  print(node.hex(hg.peer(ui, {}, url).lookup(rev)).decode('utf-8'))

lib/time/mkzip.go

@@ -1,94 +0,0 @@
-// Copyright 2022 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.
-
-//go:build ignore
-
-// Mkzip writes a zoneinfo.zip with the content of the current directory
-// and its subdirectories, with no compression, suitable for package time.
-//
-// Usage:
-//
-//	go run ../../mkzip.go ../../zoneinfo.zip
-//
-// We use this program instead of 'zip -0 -r ../../zoneinfo.zip *' to get
-// a reproducible generator that does not depend on which version of the
-// external zip tool is used or the ordering of file names in a directory
-// or the current time.
-package main
-
-import (
-	"archive/zip"
-	"bytes"
-	"flag"
-	"fmt"
-	"hash/crc32"
-	"io/fs"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-func usage() {
-	fmt.Fprintf(os.Stderr, "usage: go run mkzip.go zoneinfo.zip\n")
-	os.Exit(2)
-}
-
-func main() {
-	log.SetPrefix("mkzip: ")
-	log.SetFlags(0)
-	flag.Usage = usage
-	flag.Parse()
-	args := flag.Args()
-	if len(args) != 1 || !strings.HasSuffix(args[0], ".zip") {
-		usage()
-	}
-
-	var zb bytes.Buffer
-	zw := zip.NewWriter(&zb)
-	seen := make(map[string]bool)
-	err := filepath.WalkDir(".", func(path string, d fs.DirEntry, err error) error {
-		if d.IsDir() {
-			return nil
-		}
-		data, err := os.ReadFile(path)
-		if err != nil {
-			log.Fatal(err)
-		}
-		if strings.HasSuffix(path, ".zip") {
-			log.Fatalf("unexpected file during walk: %s", path)
-		}
-		name := filepath.ToSlash(path)
-		w, err := zw.CreateRaw(&zip.FileHeader{
-			Name:               name,
-			Method:             zip.Store,
-			CompressedSize64:   uint64(len(data)),
-			UncompressedSize64: uint64(len(data)),
-			CRC32:              crc32.ChecksumIEEE(data),
-		})
-		if err != nil {
-			log.Fatal(err)
-		}
-		if _, err := w.Write(data); err != nil {
-			log.Fatal(err)
-		}
-		seen[name] = true
-		return nil
-	})
-	if err != nil {
-		log.Fatal(err)
-	}
-	if err := zw.Close(); err != nil {
-		log.Fatal(err)
-	}
-	if len(seen) == 0 {
-		log.Fatalf("did not find any files to add")
-	}
-	if !seen["US/Eastern"] {
-		log.Fatalf("did not find US/Eastern to add")
-	}
-	if err := os.WriteFile(args[0], zb.Bytes(), 0666); err != nil {
-		log.Fatal(err)
-	}
-}

lib/time/update.bash

@@ -5,87 +5,35 @@
 
 # This script rebuilds the time zone files using files
 # downloaded from the ICANN/IANA distribution.
-#
-# To prepare an update for a new Go release,
-# consult https://www.iana.org/time-zones for the latest versions,
-# update CODE and DATA below, and then run
-#
-#	./update.bash -commit
-#
-# That will prepare the files and create the commit.
-#
-# To review such a commit (as the reviewer), use:
-#
-#	git codereview change NNNNNN   # CL number
-#	cd lib/time
-#	./update.bash
-#
-# If it prints "No updates needed.", then the generated files
-# in the CL match the update.bash in the CL.
+# Consult https://www.iana.org/time-zones for the latest versions.
 
 # Versions to use.
-CODE=2025c
-DATA=2025c
+CODE=2021e
+DATA=2021e
 
 set -e
-
-cd $(dirname $0)
 rm -rf work
 mkdir work
-go build -o work/mkzip mkzip.go # build now for correct paths in build errors
 cd work
 mkdir zoneinfo
-curl -sS -L -O https://www.iana.org/time-zones/repository/releases/tzcode$CODE.tar.gz
-curl -sS -L -O https://www.iana.org/time-zones/repository/releases/tzdata$DATA.tar.gz
+curl -L -O https://www.iana.org/time-zones/repository/releases/tzcode$CODE.tar.gz
+curl -L -O https://www.iana.org/time-zones/repository/releases/tzdata$DATA.tar.gz
 tar xzf tzcode$CODE.tar.gz
 tar xzf tzdata$DATA.tar.gz
 
-# The PACKRATLIST and PACKRATDATA options are copied from Ubuntu:
-# https://git.launchpad.net/ubuntu/+source/tzdata/tree/debian/rules?h=debian/sid
-#
-# You can see the description of these make variables in the tzdata Makefile:
-# https://github.com/eggert/tz/blob/main/Makefile
-if ! make CFLAGS=-DSTD_INSPIRED AWK=awk TZDIR=zoneinfo PACKRATDATA=backzone PACKRATLIST=zone.tab posix_only >make.out 2>&1; then
-	cat make.out
-	exit 2
-fi
+make CFLAGS=-DSTD_INSPIRED AWK=awk TZDIR=zoneinfo posix_only
 
 cd zoneinfo
-../mkzip ../../zoneinfo.zip
+rm -f ../../zoneinfo.zip
+zip -0 -r ../../zoneinfo.zip *
 cd ../..
 
-files="update.bash zoneinfo.zip"
-modified=true
-if git diff --quiet $files; then
-	modified=false
-fi
+go generate time/tzdata
 
+echo
 if [ "$1" = "-work" ]; then
 	echo Left workspace behind in work/.
-	shift
 else
 	rm -rf work
 fi
-
-if ! $modified; then
-	echo No updates needed.
-	exit 0
-fi
-
-echo Updated for $CODE/$DATA: $files
-
-commitmsg="lib/time: update to $CODE/$DATA
-
-Commit generated by update.bash.
-
-For #22487.
-"
-
-if [ "$1" = "-commit" ]; then
-	echo "Creating commit. Run 'git reset HEAD^' to undo commit."
-	echo
-	git commit -m "$commitmsg" $files
-	echo
-	git log -n1 --stat
-	echo
-fi
+echo New time zone files in zoneinfo.zip.