[dev.unified] all: merge master (85d87b9) into dev.unifieddev.unified

Merge List:

+ 2022-08-04 85d87b9c75 all: update vendored golang.org/x dependencies for Go 1.20 development
+ 2022-08-04 fb1bfd4d37 all: remove pre-Go 1.17 workarounds
+ 2022-08-04 44ff9bff0c runtime: clean up panic and deadlock lock ranks
+ 2022-08-04 f42dc0de74 runtime: make the lock rank DAG make more sense
+ 2022-08-04 d29a0282e9 runtime: add mayAcquire annotation for finlock
+ 2022-08-04 c5be4ed7df runtime: add missing trace lock edges
+ 2022-08-04 2b8a9a484f runtime: generate the lock ranking from a DAG description
+ 2022-08-04 ddfd639408 runtime: delete unused lock ranks
+ 2022-08-04 426ea5702b internal/dag: add a Graph type and make node order deterministic
+ 2022-08-04 d37cc9a8cd go/build, internal/dag: lift DAG parser into an internal package
+ 2022-08-04 ab0a94c6d3 cmd/dist: require Go 1.17 for building Go
+ 2022-08-04 1e3c19f3fe runtime: support riscv64 SV57 mode
+ 2022-08-03 f28fa952b5 make.bat, make.rc: show bootstrap toolchain version
+ 2022-08-03 87384801dc cmd/asm: update package doc to describe "-p" option
+ 2022-08-03 c6a2dada0d net: disable TestIPv6WriteMsgUDPAddrPortTargetAddrIPVersion [sic] on DragonflyBSD
+ 2022-08-02 29b9a328d2 runtime: trivial replacements of g in remaining files
+ 2022-08-02 c647264619 runtime: trivial replacements of g in signal_unix.go
+ 2022-08-02 399f50c9d7 runtime: tricky replacements of g in traceback.go
+ 2022-08-02 4509e951ec runtime: tricky replacements of g in proc.go
+ 2022-08-02 4400238ec8 runtime: trivial replacements of _g_ in remaining files
+ 2022-08-02 5999a28de8 runtime: trivial replacements of _g_ in os files
+ 2022-08-02 0e18cf6d09 runtime: trivial replacements of _g_ in GC files
+ 2022-08-02 4358a53a97 runtime: trivial replacements of _g_ in proc.go
+ 2022-08-02 b486518964 runtime: tricky replacements of _g_ in os3_solaris.go
+ 2022-08-02 54a0ab3f7b runtime: tricky replacements of _g_ in os3_plan9.go
+ 2022-08-02 4240ff764b runtime: tricky replacements of _g_ in signal_windows.go
+ 2022-08-02 8666d89ca8 runtime: tricky replacements of _g_ in signal_unix.go
+ 2022-08-02 74cee276fe runtime: tricky replacements of _g_ in trace.go
+ 2022-08-02 222799fde6 runtime: tricky replacements of _g_ in mgc.go
+ 2022-08-02 e9d7f54a1a runtime: tricky replacements of _g_ in proc.go
+ 2022-08-02 5e8d261918 runtime: rename _p_ to pp
+ 2022-08-02 0ad2ec6596 runtime: clean up dopanic_m
+ 2022-08-02 7e952962df runtime: clean up canpanic
+ 2022-08-02 9dbc0f3556 runtime: fix outdated g.m comment in traceback.go
+ 2022-08-02 d723df76da internal/goversion: update Version to 1.20
+ 2022-08-02 1b7e71e8ae all: disable tests that fail on Alpine
+ 2022-08-01 f2a9f3e2e0 test: improve generic type assertion test
+ 2022-08-01 27038b70f8 cmd/compile: fix wrong dict pass condition for type assertions
+ 2022-08-01 e99f53fed9 doc: move Go 1.19 release notes to x/website
+ 2022-08-01 8b13a073a1 doc: mention removal of cmd/compile's -importmap and -installsuffix flags
+ 2022-08-01 e95fd4c238 doc/go1.19: fix typo: EM_LONGARCH -> EM_LOONGARCH
+ 2022-08-01 dee3efd9f8 doc/go1.19: fix a few links that were missing trailing slashes
+ 2022-07-30 f32519e5fb runtime: fix typos
+ 2022-07-29 9a2001a8cc cmd/dist: always pass -short=true with -quick
+ 2022-07-28 5c8ec89cb5 doc/go1.19: minor adjustments and links
+ 2022-07-28 417be37048 doc/go1.19: improve the loong64 release notes
+ 2022-07-28 027855e8d8 os/exec: add GODEBUG setting to opt out of ErrDot changes

Change-Id: Idc0fbe93978c0dff7600b90a2c3ecc067fd9f5f2

1 files changed, 0 insertions, 237 deletions

diff --git a/src/cmd/vendor/golang.org/x/tools/internal/lsp/fuzzy/symbol.go b/src/cmd/vendor/golang.org/x/tools/internal/lsp/fuzzy/symbol.go
deleted file mode 100644
index 073a4cd101..0000000000
--- a/src/cmd/vendor/golang.org/x/tools/internal/lsp/fuzzy/symbol.go
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package fuzzy
-
-import (
-	"unicode"
-)
-
-// SymbolMatcher implements a fuzzy matching algorithm optimized for Go symbols
-// of the form:
-//
-//	example.com/path/to/package.object.field
-//
-// Knowing that we are matching symbols like this allows us to make the
-// following optimizations:
-//   - We can incorporate right-to-left relevance directly into the score
-//     calculation.
-//   - We can match from right to left, discarding leading bytes if the input is
-//     too long.
-//   - We just take the right-most match without losing too much precision. This
-//     allows us to use an O(n) algorithm.
-//   - We can operate directly on chunked strings; in many cases we will
-//     be storing the package path and/or package name separately from the
-//     symbol or identifiers, so doing this avoids allocating strings.
-//   - We can return the index of the right-most match, allowing us to trim
-//     irrelevant qualification.
-//
-// This implementation is experimental, serving as a reference fast algorithm
-// to compare to the fuzzy algorithm implemented by Matcher.
-type SymbolMatcher struct {
-	// Using buffers of length 256 is both a reasonable size for most qualified
-	// symbols, and makes it easy to avoid bounds checks by using uint8 indexes.
-	pattern     [256]rune
-	patternLen  uint8
-	inputBuffer [256]rune   // avoid allocating when considering chunks
-	roles       [256]uint32 // which roles does a rune play (word start, etc.)
-	segments    [256]uint8  // how many segments from the right is each rune
-}
-
-const (
-	segmentStart uint32 = 1 << iota
-	wordStart
-	separator
-)
-
-// NewSymbolMatcher creates a SymbolMatcher that may be used to match the given
-// search pattern.
-//
-// Currently this matcher only accepts case-insensitive fuzzy patterns.
-//
-// An empty pattern matches no input.
-func NewSymbolMatcher(pattern string) *SymbolMatcher {
-	m := &SymbolMatcher{}
-	for _, p := range pattern {
-		m.pattern[m.patternLen] = unicode.ToLower(p)
-		m.patternLen++
-		if m.patternLen == 255 || int(m.patternLen) == len(pattern) {
-			// break at 255 so that we can represent patternLen with a uint8.
-			break
-		}
-	}
-	return m
-}
-
-// Match looks for the right-most match of the search pattern within the symbol
-// represented by concatenating the given chunks, returning its offset and
-// score.
-//
-// If a match is found, the first return value will hold the absolute byte
-// offset within all chunks for the start of the symbol. In other words, the
-// index of the match within strings.Join(chunks, ""). If no match is found,
-// the first return value will be -1.
-//
-// The second return value will be the score of the match, which is always
-// between 0 and 1, inclusive. A score of 0 indicates no match.
-func (m *SymbolMatcher) Match(chunks []string) (int, float64) {
-	// Explicit behavior for an empty pattern.
-	//
-	// As a minor optimization, this also avoids nilness checks later on, since
-	// the compiler can prove that m != nil.
-	if m.patternLen == 0 {
-		return -1, 0
-	}
-
-	// First phase: populate the input buffer with lower-cased runes.
-	//
-	// We could also check for a forward match here, but since we'd have to write
-	// the entire input anyway this has negligible impact on performance.
-
-	var (
-		inputLen  = uint8(0)
-		modifiers = wordStart | segmentStart
-	)
-
-input:
-	for _, chunk := range chunks {
-		for _, r := range chunk {
-			if r == '.' || r == '/' {
-				modifiers |= separator
-			}
-			// optimization: avoid calls to unicode.ToLower, which can't be inlined.
-			l := r
-			if r <= unicode.MaxASCII {
-				if 'A' <= r && r <= 'Z' {
-					l = r + 'a' - 'A'
-				}
-			} else {
-				l = unicode.ToLower(r)
-			}
-			if l != r {
-				modifiers |= wordStart
-			}
-			m.inputBuffer[inputLen] = l
-			m.roles[inputLen] = modifiers
-			inputLen++
-			if m.roles[inputLen-1]&separator != 0 {
-				modifiers = wordStart | segmentStart
-			} else {
-				modifiers = 0
-			}
-			// TODO: we should prefer the right-most input if it overflows, rather
-			//       than the left-most as we're doing here.
-			if inputLen == 255 {
-				break input
-			}
-		}
-	}
-
-	// Second phase: find the right-most match, and count segments from the
-	// right.
-
-	var (
-		pi    = uint8(m.patternLen - 1) // pattern index
-		p     = m.pattern[pi]           // pattern rune
-		start = -1                      // start offset of match
-		rseg  = uint8(0)
-	)
-	const maxSeg = 3 // maximum number of segments from the right to count, for scoring purposes.
-
-	for ii := inputLen - 1; ; ii-- {
-		r := m.inputBuffer[ii]
-		if rseg < maxSeg && m.roles[ii]&separator != 0 {
-			rseg++
-		}
-		m.segments[ii] = rseg
-		if p == r {
-			if pi == 0 {
-				start = int(ii)
-				break
-			}
-			pi--
-			p = m.pattern[pi]
-		}
-		// Don't check ii >= 0 in the loop condition: ii is a uint8.
-		if ii == 0 {
-			break
-		}
-	}
-
-	if start < 0 {
-		// no match: skip scoring
-		return -1, 0
-	}
-
-	// Third phase: find the shortest match, and compute the score.
-
-	// Score is the average score for each character.
-	//
-	// A character score is the multiple of:
-	//   1. 1.0 if the character starts a segment, .8 if the character start a
-	//      mid-segment word, otherwise 0.6. This carries over to immediately
-	//      following characters.
-	//   2. For the final character match, the multiplier from (1) is reduced to
-	//     .8 if the next character in the input is a mid-segment word, or 0.6 if
-	//      the next character in the input is not a word or segment start. This
-	//      ensures that we favor whole-word or whole-segment matches over prefix
-	//      matches.
-	//   3. 1.0 if the character is part of the last segment, otherwise
-	//      1.0-.2*<segments from the right>, with a max segment count of 3.
-	//
-	// This is a very naive algorithm, but it is fast. There's lots of prior art
-	// here, and we should leverage it. For example, we could explicitly consider
-	// character distance, and exact matches of words or segments.
-	//
-	// Also note that this might not actually find the highest scoring match, as
-	// doing so could require a non-linear algorithm, depending on how the score
-	// is calculated.
-
-	pi = 0
-	p = m.pattern[pi]
-
-	const (
-		segStreak  = 1.0
-		wordStreak = 0.8
-		noStreak   = 0.6
-		perSegment = 0.2 // we count at most 3 segments above
-	)
-
-	streakBonus := noStreak
-	totScore := 0.0
-	for ii := uint8(start); ii < inputLen; ii++ {
-		r := m.inputBuffer[ii]
-		if r == p {
-			pi++
-			p = m.pattern[pi]
-			// Note: this could be optimized with some bit operations.
-			switch {
-			case m.roles[ii]&segmentStart != 0 && segStreak > streakBonus:
-				streakBonus = segStreak
-			case m.roles[ii]&wordStart != 0 && wordStreak > streakBonus:
-				streakBonus = wordStreak
-			}
-			finalChar := pi >= m.patternLen
-			// finalCost := 1.0
-			if finalChar && streakBonus > noStreak {
-				switch {
-				case ii == inputLen-1 || m.roles[ii+1]&segmentStart != 0:
-					// Full segment: no reduction
-				case m.roles[ii+1]&wordStart != 0:
-					streakBonus = wordStreak
-				default:
-					streakBonus = noStreak
-				}
-			}
-			totScore += streakBonus * (1.0 - float64(m.segments[ii])*perSegment)
-			if finalChar {
-				break
-			}
-		} else {
-			streakBonus = noStreak
-		}
-	}
-
-	return start, totScore / float64(m.patternLen)
-}