gopls/doc/release: tweak v0.19

Updates golang/go#73965

Change-Id: I532438e160a99bb1754d1de4ed9015eae3880fb9
Reviewed-on: https://go-review.googlesource.com/c/tools/+/678759
Reviewed-by: Robert Findley <[email protected]>
Auto-Submit: Alan Donovan <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: adonovan

gopls/doc/release/v0.19.0.md

@@ -1,71 +1,15 @@
 # Configuration Changes
 
-- The `gopls check` subcommant now accepts a `-severity` flag to set a minimum
+- The `gopls check` subcommand now accepts a `-severity` flag to set a minimum
   severity for the diagnostics it reports. By default, the minimum severity
   is "warning", so `gopls check` may report fewer diagnostics than before. Set
   `-severity=hint` to reproduce the previous behavior.
 
-# New features
+# Navigation features
 
-##  "Rename" of method receivers
+## "Implementations" supports signature types (within same package)
 
-The Rename operation, when applied to the declaration of a method
-receiver, now also attempts to rename the receivers of all other
-methods associated with the same named type. Each other receiver that
-cannot be fully renamed is quietly skipped.
-
-Renaming a _use_ of a method receiver continues to affect only that
-variable.
-
-```go
-type Counter struct { x int }
-
-                 Rename here to affect only this method
-                          ↓
-func (c *Counter) Inc() { c.x++ }
-func (c *Counter) Dec() { c.x++ }
-      ↑
-  Rename here to affect all methods
-```
-
-## Many `staticcheck` analyzers are enabled by default
-
-Slightly more than half of the analyzers in the
-[Staticcheck](https://staticcheck.dev/docs/checks) suite are now
-enabled by default. This subset has been chosen for precision and
-efficiency.
-
-Previously, Staticcheck analyzers (all of them) would be run only if
-the experimental `staticcheck` boolean option was set to `true`. This
-value continues to enable the complete set, and a value of `false`
-continues to disable the complete set. Leaving the option unspecified
-enables the preferred subset of analyzers.
-
-Staticcheck analyzers, like all other analyzers, can be explicitly
-enabled or disabled using the `analyzers` configuration setting; this
-setting now takes precedence over the `staticcheck` setting, so,
-regardless of what value of `staticcheck` you use (true/false/unset),
-you can make adjustments to your preferred set of analyzers.
-
-## "Inefficient recursive iterator" analyzer
-
-A common pitfall when writing a function that returns an iterator
-(iter.Seq) for a recursive data type is to recursively call the
-function from its own implementation, leading to a stack of nested
-coroutines, which is inefficient.
-
-The new `recursiveiter` analyzer detects such mistakes; see
-[https://golang.org/x/tools/gopls/internal/analysis/recursiveiter](its
-documentation) for details, including tips on how to define simple and
-efficient recursive iterators.
-
-##  "Inefficient range over maps.Keys/Values" analyzer
-
-This analyzer detects redundant calls to `maps.Keys` or `maps.Values`
-as the operand of a range loop; maps can of course be ranged over
-directly.
-
-##  "Implementations" supports signature types
+<!-- golang/go#56572 -->
 
 The Implementations query reports the correspondence between abstract
 and concrete types and their methods based on their method sets.
@@ -89,9 +33,11 @@ Queries using method-sets should be invoked on the type or method name,
 and queries using signatures should be invoked on a `func` or `(` token.
 
 Only the local (same-package) algorithm is currently supported.
-TODO: implement global.
+(https://go.dev/issue/56572 tracks the global algorithm.)
 
-## Go to Implementation
+## "Go to Implementation" reports interface-to-interface relations
+
+<!-- golang/go#68641 -->
 
 The "Go to Implementation" operation now reports relationships between
 interfaces. Gopls now uses the concreteness of the query type to
@@ -126,19 +72,102 @@ of the selected named type.
 
 <img title="Type Hierarchy: subtypes of io.Writer" src="../assets/subtypes.png" width="400">
 
-## "Eliminate dot import" code action
 
-This code action, available on a dotted import, will offer to replace
-the import with a regular one and qualify each use of the package
-with its name.
+# Editing features
 
-### Auto-complete package clause for new Go files
+## Completion: auto-complete package clause for new Go files
 
 Gopls now automatically adds the appropriate `package` clause to newly created Go files,
 so that you can immediately get started writing the interesting part.
 
 It requires client support for `workspace/didCreateFiles`
 
+## New GOMODCACHE index for faster Organize Imports and unimported completions
+
+By default, gopls now builds and maintains a persistent index of
+packages in the module cache (GOMODCACHE). The operations of Organize
+Imports and completion of symbols from unimported pacakges are an
+order of magnitude faster.
+
+To revert to the old behavior, set the `importsSource` option (whose
+new default is `"gopls"`) to `"goimports"`. Users who don't want the
+module cache used at all for imports or completions can change the
+option to "off".
+
+# Analysis features
+
+## Most `staticcheck` analyzers are enabled by default
+
+Slightly more than half of the analyzers in the
+[Staticcheck](https://staticcheck.dev/docs/checks) suite are now
+enabled by default. This subset has been chosen for precision and
+efficiency.
+
+Previously, Staticcheck analyzers (all of them) would be run only if
+the experimental `staticcheck` boolean option was set to `true`. This
+value continues to enable the complete set, and a value of `false`
+continues to disable the complete set. Leaving the option unspecified
+enables the preferred subset of analyzers.
+
+Staticcheck analyzers, like all other analyzers, can be explicitly
+enabled or disabled using the `analyzers` configuration setting; this
+setting now takes precedence over the `staticcheck` setting, so,
+regardless of what value of `staticcheck` you use (true/false/unset),
+you can make adjustments to your preferred set of analyzers.
+
+## `recursiveiter`: "inefficient recursive iterator"
+
+A common pitfall when writing a function that returns an iterator
+(`iter.Seq`) for a recursive data type is to recursively call the
+function from its own implementation, leading to a stack of nested
+coroutines, which is inefficient.
+
+The new `recursiveiter` analyzer detects such mistakes; see
+[its documentation](https://golang.org/x/tools/gopls/internal/analysis/recursiveiter)
+for details, including tips on how to define simple and efficient
+recursive iterators.
+
+## `maprange`: "inefficient range over maps.Keys/Values"
+
+The new `maprange` analyzer detects redundant calls to `maps.Keys` or
+`maps.Values` as the operand of a range loop; maps can of course be
+ranged over directly. See
+[its documentation](https://pkg.go.dev/golang.org/x/tools/gopls/internal/analysis/maprange)
+for details).
+
+# Code transformation features
+
+## Rename method receivers
+
+<!-- golang/go#41892 -->
+
+The Rename operation, when applied to the declaration of a method
+receiver, now also attempts to rename the receivers of all other
+methods associated with the same named type. Each other receiver that
+cannot be fully renamed is quietly skipped.
+
+Renaming a _use_ of a method receiver continues to affect only that
+variable.
+
+```go
+type Counter struct { x int }
+
+                 Rename here to affect only this method
+                          ↓
+func (c *Counter) Inc() { c.x++ }
+func (c *Counter) Dec() { c.x++ }
+      ↑
+  Rename here to affect all methods
+```
+
+## "Eliminate dot import" code action
+
+<!-- golang/go#70319 -->
+
+This code action, available on a dotted import, will offer to replace
+the import with a regular one and qualify each use of the package
+with its name.
+
 ## Add/remove tags from struct fields
 
 Gopls now provides two new code actions, available on an entire struct
@@ -156,6 +185,8 @@ type Info struct {
 
 ## Inline local variable
 
+<!-- golang/go#70085 -->
+
 The new `refactor.inline.variable` code action replaces a reference to
 a local variable by that variable's initializer expression. For
 example, when applied to `s` in `println(s)`:
@@ -174,14 +205,6 @@ func f(x int) {
 }
 ```
 
-## Use index for GOMODCACHE in imports and unimported completions
-
-The default for the option `importsSource` changes from "goimports" to "gopls".
-This has the effect of building and maintaining an index to
-the packages in GOMODCACHE.
-The index is stored in the directory `os.UserCacheDir()/go/imports`.
-Users who want the old behavior can change the option back. Users who don't
-the module cache used at all for imports or completions
-can change the option to
-"off". The new code is many times faster than the old when accessing the
-module cache.
+Only a single reference is replaced; issue https://go.dev/issue/70085
+tracks the feature to "inline all" uses of the variable and eliminate
+it.