rebase: update to latest snapshotter

this commit update the snapshotter client to v6.1.0

Signed-off-by: Humble Chirammal <hchiramm@redhat.com>
This commit is contained in:
Humble Chirammal 2022-11-11 09:36:17 +05:30 committed by mergify[bot]
parent 8b078f1a11
commit c9ccbf29bb
115 changed files with 2526 additions and 10113 deletions

20
go.mod
View File

@ -1,6 +1,6 @@
module github.com/ceph/ceph-csi module github.com/ceph/ceph-csi
go 1.17 go 1.18
require ( require (
github.com/IBM/keyprotect-go-client v0.9.0 github.com/IBM/keyprotect-go-client v0.9.0
@ -20,7 +20,7 @@ require (
github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0
github.com/hashicorp/vault/api v1.8.2 github.com/hashicorp/vault/api v1.8.2
github.com/kubernetes-csi/csi-lib-utils v0.11.0 github.com/kubernetes-csi/csi-lib-utils v0.11.0
github.com/kubernetes-csi/external-snapshotter/client/v6 v6.0.1 github.com/kubernetes-csi/external-snapshotter/client/v6 v6.1.0
github.com/libopenstorage/secrets v0.0.0-20210908194121-a1d19aa9713a github.com/libopenstorage/secrets v0.0.0-20210908194121-a1d19aa9713a
github.com/onsi/ginkgo/v2 v2.4.0 github.com/onsi/ginkgo/v2 v2.4.0
github.com/onsi/gomega v1.23.0 github.com/onsi/gomega v1.23.0
@ -31,7 +31,7 @@ require (
golang.org/x/net v0.1.0 golang.org/x/net v0.1.0
golang.org/x/sys v0.2.0 golang.org/x/sys v0.2.0
google.golang.org/grpc v1.50.1 google.golang.org/grpc v1.50.1
google.golang.org/protobuf v1.28.0 google.golang.org/protobuf v1.28.1
k8s.io/api v0.25.3 k8s.io/api v0.25.3
k8s.io/apimachinery v0.25.3 k8s.io/apimachinery v0.25.3
k8s.io/client-go v12.0.0+incompatible k8s.io/client-go v12.0.0+incompatible
@ -48,8 +48,6 @@ require (
) )
require ( require (
github.com/PuerkitoBio/purell v1.1.1 // indirect
github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 // indirect
github.com/ansel1/merry v1.6.2 // indirect github.com/ansel1/merry v1.6.2 // indirect
github.com/ansel1/merry/v2 v2.0.1 // indirect github.com/ansel1/merry/v2 v2.0.1 // indirect
github.com/armon/go-metrics v0.3.9 // indirect github.com/armon/go-metrics v0.3.9 // indirect
@ -65,7 +63,7 @@ require (
github.com/cespare/xxhash/v2 v2.1.2 // indirect github.com/cespare/xxhash/v2 v2.1.2 // indirect
github.com/davecgh/go-spew v1.1.1 // indirect github.com/davecgh/go-spew v1.1.1 // indirect
github.com/docker/distribution v2.8.1+incompatible // indirect github.com/docker/distribution v2.8.1+incompatible // indirect
github.com/emicklei/go-restful/v3 v3.8.0 // indirect github.com/emicklei/go-restful/v3 v3.9.0 // indirect
github.com/evanphx/json-patch v4.12.0+incompatible // indirect github.com/evanphx/json-patch v4.12.0+incompatible // indirect
github.com/fatih/color v1.9.0 // indirect github.com/fatih/color v1.9.0 // indirect
github.com/felixge/httpsnoop v1.0.1 // indirect github.com/felixge/httpsnoop v1.0.1 // indirect
@ -74,13 +72,13 @@ require (
github.com/ghodss/yaml v1.0.1-0.20190212211648-25d852aebe32 // indirect github.com/ghodss/yaml v1.0.1-0.20190212211648-25d852aebe32 // indirect
github.com/go-logr/logr v1.2.3 // indirect github.com/go-logr/logr v1.2.3 // indirect
github.com/go-openapi/jsonpointer v0.19.5 // indirect github.com/go-openapi/jsonpointer v0.19.5 // indirect
github.com/go-openapi/jsonreference v0.19.5 // indirect github.com/go-openapi/jsonreference v0.20.0 // indirect
github.com/go-openapi/swag v0.19.14 // indirect github.com/go-openapi/swag v0.22.3 // indirect
github.com/go-sql-driver/mysql v1.5.0 // indirect github.com/go-sql-driver/mysql v1.5.0 // indirect
github.com/gogo/protobuf v1.3.2 // indirect github.com/gogo/protobuf v1.3.2 // indirect
github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
github.com/golang/snappy v0.0.4 // indirect github.com/golang/snappy v0.0.4 // indirect
github.com/google/gnostic v0.5.7-v3refs // indirect github.com/google/gnostic v0.6.9 // indirect
github.com/google/go-cmp v0.5.9 // indirect github.com/google/go-cmp v0.5.9 // indirect
github.com/google/gofuzz v1.1.0 // indirect github.com/google/gofuzz v1.1.0 // indirect
github.com/grpc-ecosystem/grpc-gateway v1.16.0 // indirect github.com/grpc-ecosystem/grpc-gateway v1.16.0 // indirect
@ -109,7 +107,7 @@ require (
github.com/josharian/intern v1.0.0 // indirect github.com/josharian/intern v1.0.0 // indirect
github.com/json-iterator/go v1.1.12 // indirect github.com/json-iterator/go v1.1.12 // indirect
github.com/kr/pretty v0.2.1 // indirect github.com/kr/pretty v0.2.1 // indirect
github.com/mailru/easyjson v0.7.6 // indirect github.com/mailru/easyjson v0.7.7 // indirect
github.com/mattn/go-colorable v0.1.13 // indirect github.com/mattn/go-colorable v0.1.13 // indirect
github.com/mattn/go-isatty v0.0.16 // indirect github.com/mattn/go-isatty v0.0.16 // indirect
github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 // indirect github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 // indirect
@ -165,7 +163,7 @@ require (
k8s.io/apiserver v0.25.3 // indirect k8s.io/apiserver v0.25.3 // indirect
k8s.io/component-base v0.25.3 // indirect k8s.io/component-base v0.25.3 // indirect
k8s.io/component-helpers v0.25.3 // indirect k8s.io/component-helpers v0.25.3 // indirect
k8s.io/kube-openapi v0.0.0-20220803162953-67bda5d908f1 // indirect k8s.io/kube-openapi v0.0.0-20220803164354-a70c9af30aea // indirect
k8s.io/kubectl v0.0.0 // indirect k8s.io/kubectl v0.0.0 // indirect
k8s.io/kubelet v0.0.0 // indirect k8s.io/kubelet v0.0.0 // indirect
sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.33 // indirect sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.33 // indirect

287
go.sum

File diff suppressed because it is too large Load Diff

View File

@ -1,5 +0,0 @@
*.sublime-*
.DS_Store
*.swp
*.swo
tags

View File

@ -1,12 +0,0 @@
language: go
go:
- 1.4.x
- 1.5.x
- 1.6.x
- 1.7.x
- 1.8.x
- 1.9.x
- "1.10.x"
- "1.11.x"
- tip

View File

@ -1,12 +0,0 @@
Copyright (c) 2012, Martin Angers
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above 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 the author nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

View File

@ -1,188 +0,0 @@
# Purell
Purell is a tiny Go library to normalize URLs. It returns a pure URL. Pure-ell. Sanitizer and all. Yeah, I know...
Based on the [wikipedia paper][wiki] and the [RFC 3986 document][rfc].
[![build status](https://travis-ci.org/PuerkitoBio/purell.svg?branch=master)](http://travis-ci.org/PuerkitoBio/purell)
## Install
`go get github.com/PuerkitoBio/purell`
## Changelog
* **v1.1.1** : Fix failing test due to Go1.12 changes (thanks to @ianlancetaylor).
* **2016-11-14 (v1.1.0)** : IDN: Conform to RFC 5895: Fold character width (thanks to @beeker1121).
* **2016-07-27 (v1.0.0)** : Normalize IDN to ASCII (thanks to @zenovich).
* **2015-02-08** : Add fix for relative paths issue ([PR #5][pr5]) and add fix for unnecessary encoding of reserved characters ([see issue #7][iss7]).
* **v0.2.0** : Add benchmarks, Attempt IDN support.
* **v0.1.0** : Initial release.
## Examples
From `example_test.go` (note that in your code, you would import "github.com/PuerkitoBio/purell", and would prefix references to its methods and constants with "purell."):
```go
package purell
import (
"fmt"
"net/url"
)
func ExampleNormalizeURLString() {
if normalized, err := NormalizeURLString("hTTp://someWEBsite.com:80/Amazing%3f/url/",
FlagLowercaseScheme|FlagLowercaseHost|FlagUppercaseEscapes); err != nil {
panic(err)
} else {
fmt.Print(normalized)
}
// Output: http://somewebsite.com:80/Amazing%3F/url/
}
func ExampleMustNormalizeURLString() {
normalized := MustNormalizeURLString("hTTpS://someWEBsite.com:443/Amazing%fa/url/",
FlagsUnsafeGreedy)
fmt.Print(normalized)
// Output: http://somewebsite.com/Amazing%FA/url
}
func ExampleNormalizeURL() {
if u, err := url.Parse("Http://SomeUrl.com:8080/a/b/.././c///g?c=3&a=1&b=9&c=0#target"); err != nil {
panic(err)
} else {
normalized := NormalizeURL(u, FlagsUsuallySafeGreedy|FlagRemoveDuplicateSlashes|FlagRemoveFragment)
fmt.Print(normalized)
}
// Output: http://someurl.com:8080/a/c/g?c=3&a=1&b=9&c=0
}
```
## API
As seen in the examples above, purell offers three methods, `NormalizeURLString(string, NormalizationFlags) (string, error)`, `MustNormalizeURLString(string, NormalizationFlags) (string)` and `NormalizeURL(*url.URL, NormalizationFlags) (string)`. They all normalize the provided URL based on the specified flags. Here are the available flags:
```go
const (
// Safe normalizations
FlagLowercaseScheme NormalizationFlags = 1 << iota // HTTP://host -> http://host, applied by default in Go1.1
FlagLowercaseHost // http://HOST -> http://host
FlagUppercaseEscapes // http://host/t%ef -> http://host/t%EF
FlagDecodeUnnecessaryEscapes // http://host/t%41 -> http://host/tA
FlagEncodeNecessaryEscapes // http://host/!"#$ -> http://host/%21%22#$
FlagRemoveDefaultPort // http://host:80 -> http://host
FlagRemoveEmptyQuerySeparator // http://host/path? -> http://host/path
// Usually safe normalizations
FlagRemoveTrailingSlash // http://host/path/ -> http://host/path
FlagAddTrailingSlash // http://host/path -> http://host/path/ (should choose only one of these add/remove trailing slash flags)
FlagRemoveDotSegments // http://host/path/./a/b/../c -> http://host/path/a/c
// Unsafe normalizations
FlagRemoveDirectoryIndex // http://host/path/index.html -> http://host/path/
FlagRemoveFragment // http://host/path#fragment -> http://host/path
FlagForceHTTP // https://host -> http://host
FlagRemoveDuplicateSlashes // http://host/path//a///b -> http://host/path/a/b
FlagRemoveWWW // http://www.host/ -> http://host/
FlagAddWWW // http://host/ -> http://www.host/ (should choose only one of these add/remove WWW flags)
FlagSortQuery // http://host/path?c=3&b=2&a=1&b=1 -> http://host/path?a=1&b=1&b=2&c=3
// Normalizations not in the wikipedia article, required to cover tests cases
// submitted by jehiah
FlagDecodeDWORDHost // http://1113982867 -> http://66.102.7.147
FlagDecodeOctalHost // http://0102.0146.07.0223 -> http://66.102.7.147
FlagDecodeHexHost // http://0x42660793 -> http://66.102.7.147
FlagRemoveUnnecessaryHostDots // http://.host../path -> http://host/path
FlagRemoveEmptyPortSeparator // http://host:/path -> http://host/path
// Convenience set of safe normalizations
FlagsSafe NormalizationFlags = FlagLowercaseHost | FlagLowercaseScheme | FlagUppercaseEscapes | FlagDecodeUnnecessaryEscapes | FlagEncodeNecessaryEscapes | FlagRemoveDefaultPort | FlagRemoveEmptyQuerySeparator
// For convenience sets, "greedy" uses the "remove trailing slash" and "remove www. prefix" flags,
// while "non-greedy" uses the "add (or keep) the trailing slash" and "add www. prefix".
// Convenience set of usually safe normalizations (includes FlagsSafe)
FlagsUsuallySafeGreedy NormalizationFlags = FlagsSafe | FlagRemoveTrailingSlash | FlagRemoveDotSegments
FlagsUsuallySafeNonGreedy NormalizationFlags = FlagsSafe | FlagAddTrailingSlash | FlagRemoveDotSegments
// Convenience set of unsafe normalizations (includes FlagsUsuallySafe)
FlagsUnsafeGreedy NormalizationFlags = FlagsUsuallySafeGreedy | FlagRemoveDirectoryIndex | FlagRemoveFragment | FlagForceHTTP | FlagRemoveDuplicateSlashes | FlagRemoveWWW | FlagSortQuery
FlagsUnsafeNonGreedy NormalizationFlags = FlagsUsuallySafeNonGreedy | FlagRemoveDirectoryIndex | FlagRemoveFragment | FlagForceHTTP | FlagRemoveDuplicateSlashes | FlagAddWWW | FlagSortQuery
// Convenience set of all available flags
FlagsAllGreedy = FlagsUnsafeGreedy | FlagDecodeDWORDHost | FlagDecodeOctalHost | FlagDecodeHexHost | FlagRemoveUnnecessaryHostDots | FlagRemoveEmptyPortSeparator
FlagsAllNonGreedy = FlagsUnsafeNonGreedy | FlagDecodeDWORDHost | FlagDecodeOctalHost | FlagDecodeHexHost | FlagRemoveUnnecessaryHostDots | FlagRemoveEmptyPortSeparator
)
```
For convenience, the set of flags `FlagsSafe`, `FlagsUsuallySafe[Greedy|NonGreedy]`, `FlagsUnsafe[Greedy|NonGreedy]` and `FlagsAll[Greedy|NonGreedy]` are provided for the similarly grouped normalizations on [wikipedia's URL normalization page][wiki]. You can add (using the bitwise OR `|` operator) or remove (using the bitwise AND NOT `&^` operator) individual flags from the sets if required, to build your own custom set.
The [full godoc reference is available on gopkgdoc][godoc].
Some things to note:
* `FlagDecodeUnnecessaryEscapes`, `FlagEncodeNecessaryEscapes`, `FlagUppercaseEscapes` and `FlagRemoveEmptyQuerySeparator` are always implicitly set, because internally, the URL string is parsed as an URL object, which automatically decodes unnecessary escapes, uppercases and encodes necessary ones, and removes empty query separators (an unnecessary `?` at the end of the url). So this operation cannot **not** be done. For this reason, `FlagRemoveEmptyQuerySeparator` (as well as the other three) has been included in the `FlagsSafe` convenience set, instead of `FlagsUnsafe`, where Wikipedia puts it.
* The `FlagDecodeUnnecessaryEscapes` decodes the following escapes (*from -> to*):
- %24 -> $
- %26 -> &
- %2B-%3B -> +,-./0123456789:;
- %3D -> =
- %40-%5A -> @ABCDEFGHIJKLMNOPQRSTUVWXYZ
- %5F -> _
- %61-%7A -> abcdefghijklmnopqrstuvwxyz
- %7E -> ~
* When the `NormalizeURL` function is used (passing an URL object), this source URL object is modified (that is, after the call, the URL object will be modified to reflect the normalization).
* The *replace IP with domain name* normalization (`http://208.77.188.166/ → http://www.example.com/`) is obviously not possible for a library without making some network requests. This is not implemented in purell.
* The *remove unused query string parameters* and *remove default query parameters* are also not implemented, since this is a very case-specific normalization, and it is quite trivial to do with an URL object.
### Safe vs Usually Safe vs Unsafe
Purell allows you to control the level of risk you take while normalizing an URL. You can aggressively normalize, play it totally safe, or anything in between.
Consider the following URL:
`HTTPS://www.RooT.com/toto/t%45%1f///a/./b/../c/?z=3&w=2&a=4&w=1#invalid`
Normalizing with the `FlagsSafe` gives:
`https://www.root.com/toto/tE%1F///a/./b/../c/?z=3&w=2&a=4&w=1#invalid`
With the `FlagsUsuallySafeGreedy`:
`https://www.root.com/toto/tE%1F///a/c?z=3&w=2&a=4&w=1#invalid`
And with `FlagsUnsafeGreedy`:
`http://root.com/toto/tE%1F/a/c?a=4&w=1&w=2&z=3`
## TODOs
* Add a class/default instance to allow specifying custom directory index names? At the moment, removing directory index removes `(^|/)((?:default|index)\.\w{1,4})$`.
## Thanks / Contributions
@rogpeppe
@jehiah
@opennota
@pchristopher1275
@zenovich
@beeker1121
## License
The [BSD 3-Clause license][bsd].
[bsd]: http://opensource.org/licenses/BSD-3-Clause
[wiki]: http://en.wikipedia.org/wiki/URL_normalization
[rfc]: http://tools.ietf.org/html/rfc3986#section-6
[godoc]: http://go.pkgdoc.org/github.com/PuerkitoBio/purell
[pr5]: https://github.com/PuerkitoBio/purell/pull/5
[iss7]: https://github.com/PuerkitoBio/purell/issues/7

View File

@ -1,379 +0,0 @@
/*
Package purell offers URL normalization as described on the wikipedia page:
http://en.wikipedia.org/wiki/URL_normalization
*/
package purell
import (
"bytes"
"fmt"
"net/url"
"regexp"
"sort"
"strconv"
"strings"
"github.com/PuerkitoBio/urlesc"
"golang.org/x/net/idna"
"golang.org/x/text/unicode/norm"
"golang.org/x/text/width"
)
// A set of normalization flags determines how a URL will
// be normalized.
type NormalizationFlags uint
const (
// Safe normalizations
FlagLowercaseScheme NormalizationFlags = 1 << iota // HTTP://host -> http://host, applied by default in Go1.1
FlagLowercaseHost // http://HOST -> http://host
FlagUppercaseEscapes // http://host/t%ef -> http://host/t%EF
FlagDecodeUnnecessaryEscapes // http://host/t%41 -> http://host/tA
FlagEncodeNecessaryEscapes // http://host/!"#$ -> http://host/%21%22#$
FlagRemoveDefaultPort // http://host:80 -> http://host
FlagRemoveEmptyQuerySeparator // http://host/path? -> http://host/path
// Usually safe normalizations
FlagRemoveTrailingSlash // http://host/path/ -> http://host/path
FlagAddTrailingSlash // http://host/path -> http://host/path/ (should choose only one of these add/remove trailing slash flags)
FlagRemoveDotSegments // http://host/path/./a/b/../c -> http://host/path/a/c
// Unsafe normalizations
FlagRemoveDirectoryIndex // http://host/path/index.html -> http://host/path/
FlagRemoveFragment // http://host/path#fragment -> http://host/path
FlagForceHTTP // https://host -> http://host
FlagRemoveDuplicateSlashes // http://host/path//a///b -> http://host/path/a/b
FlagRemoveWWW // http://www.host/ -> http://host/
FlagAddWWW // http://host/ -> http://www.host/ (should choose only one of these add/remove WWW flags)
FlagSortQuery // http://host/path?c=3&b=2&a=1&b=1 -> http://host/path?a=1&b=1&b=2&c=3
// Normalizations not in the wikipedia article, required to cover tests cases
// submitted by jehiah
FlagDecodeDWORDHost // http://1113982867 -> http://66.102.7.147
FlagDecodeOctalHost // http://0102.0146.07.0223 -> http://66.102.7.147
FlagDecodeHexHost // http://0x42660793 -> http://66.102.7.147
FlagRemoveUnnecessaryHostDots // http://.host../path -> http://host/path
FlagRemoveEmptyPortSeparator // http://host:/path -> http://host/path
// Convenience set of safe normalizations
FlagsSafe NormalizationFlags = FlagLowercaseHost | FlagLowercaseScheme | FlagUppercaseEscapes | FlagDecodeUnnecessaryEscapes | FlagEncodeNecessaryEscapes | FlagRemoveDefaultPort | FlagRemoveEmptyQuerySeparator
// For convenience sets, "greedy" uses the "remove trailing slash" and "remove www. prefix" flags,
// while "non-greedy" uses the "add (or keep) the trailing slash" and "add www. prefix".
// Convenience set of usually safe normalizations (includes FlagsSafe)
FlagsUsuallySafeGreedy NormalizationFlags = FlagsSafe | FlagRemoveTrailingSlash | FlagRemoveDotSegments
FlagsUsuallySafeNonGreedy NormalizationFlags = FlagsSafe | FlagAddTrailingSlash | FlagRemoveDotSegments
// Convenience set of unsafe normalizations (includes FlagsUsuallySafe)
FlagsUnsafeGreedy NormalizationFlags = FlagsUsuallySafeGreedy | FlagRemoveDirectoryIndex | FlagRemoveFragment | FlagForceHTTP | FlagRemoveDuplicateSlashes | FlagRemoveWWW | FlagSortQuery
FlagsUnsafeNonGreedy NormalizationFlags = FlagsUsuallySafeNonGreedy | FlagRemoveDirectoryIndex | FlagRemoveFragment | FlagForceHTTP | FlagRemoveDuplicateSlashes | FlagAddWWW | FlagSortQuery
// Convenience set of all available flags
FlagsAllGreedy = FlagsUnsafeGreedy | FlagDecodeDWORDHost | FlagDecodeOctalHost | FlagDecodeHexHost | FlagRemoveUnnecessaryHostDots | FlagRemoveEmptyPortSeparator
FlagsAllNonGreedy = FlagsUnsafeNonGreedy | FlagDecodeDWORDHost | FlagDecodeOctalHost | FlagDecodeHexHost | FlagRemoveUnnecessaryHostDots | FlagRemoveEmptyPortSeparator
)
const (
defaultHttpPort = ":80"
defaultHttpsPort = ":443"
)
// Regular expressions used by the normalizations
var rxPort = regexp.MustCompile(`(:\d+)/?$`)
var rxDirIndex = regexp.MustCompile(`(^|/)((?:default|index)\.\w{1,4})$`)
var rxDupSlashes = regexp.MustCompile(`/{2,}`)
var rxDWORDHost = regexp.MustCompile(`^(\d+)((?:\.+)?(?:\:\d*)?)$`)
var rxOctalHost = regexp.MustCompile(`^(0\d*)\.(0\d*)\.(0\d*)\.(0\d*)((?:\.+)?(?:\:\d*)?)$`)
var rxHexHost = regexp.MustCompile(`^0x([0-9A-Fa-f]+)((?:\.+)?(?:\:\d*)?)$`)
var rxHostDots = regexp.MustCompile(`^(.+?)(:\d+)?$`)
var rxEmptyPort = regexp.MustCompile(`:+$`)
// Map of flags to implementation function.
// FlagDecodeUnnecessaryEscapes has no action, since it is done automatically
// by parsing the string as an URL. Same for FlagUppercaseEscapes and FlagRemoveEmptyQuerySeparator.
// Since maps have undefined traversing order, make a slice of ordered keys
var flagsOrder = []NormalizationFlags{
FlagLowercaseScheme,
FlagLowercaseHost,
FlagRemoveDefaultPort,
FlagRemoveDirectoryIndex,
FlagRemoveDotSegments,
FlagRemoveFragment,
FlagForceHTTP, // Must be after remove default port (because https=443/http=80)
FlagRemoveDuplicateSlashes,
FlagRemoveWWW,
FlagAddWWW,
FlagSortQuery,
FlagDecodeDWORDHost,
FlagDecodeOctalHost,
FlagDecodeHexHost,
FlagRemoveUnnecessaryHostDots,
FlagRemoveEmptyPortSeparator,
FlagRemoveTrailingSlash, // These two (add/remove trailing slash) must be last
FlagAddTrailingSlash,
}
// ... and then the map, where order is unimportant
var flags = map[NormalizationFlags]func(*url.URL){
FlagLowercaseScheme: lowercaseScheme,
FlagLowercaseHost: lowercaseHost,
FlagRemoveDefaultPort: removeDefaultPort,
FlagRemoveDirectoryIndex: removeDirectoryIndex,
FlagRemoveDotSegments: removeDotSegments,
FlagRemoveFragment: removeFragment,
FlagForceHTTP: forceHTTP,
FlagRemoveDuplicateSlashes: removeDuplicateSlashes,
FlagRemoveWWW: removeWWW,
FlagAddWWW: addWWW,
FlagSortQuery: sortQuery,
FlagDecodeDWORDHost: decodeDWORDHost,
FlagDecodeOctalHost: decodeOctalHost,
FlagDecodeHexHost: decodeHexHost,
FlagRemoveUnnecessaryHostDots: removeUnncessaryHostDots,
FlagRemoveEmptyPortSeparator: removeEmptyPortSeparator,
FlagRemoveTrailingSlash: removeTrailingSlash,
FlagAddTrailingSlash: addTrailingSlash,
}
// MustNormalizeURLString returns the normalized string, and panics if an error occurs.
// It takes an URL string as input, as well as the normalization flags.
func MustNormalizeURLString(u string, f NormalizationFlags) string {
result, e := NormalizeURLString(u, f)
if e != nil {
panic(e)
}
return result
}
// NormalizeURLString returns the normalized string, or an error if it can't be parsed into an URL object.
// It takes an URL string as input, as well as the normalization flags.
func NormalizeURLString(u string, f NormalizationFlags) (string, error) {
parsed, err := url.Parse(u)
if err != nil {
return "", err
}
if f&FlagLowercaseHost == FlagLowercaseHost {
parsed.Host = strings.ToLower(parsed.Host)
}
// The idna package doesn't fully conform to RFC 5895
// (https://tools.ietf.org/html/rfc5895), so we do it here.
// Taken from Go 1.8 cycle source, courtesy of bradfitz.
// TODO: Remove when (if?) idna package conforms to RFC 5895.
parsed.Host = width.Fold.String(parsed.Host)
parsed.Host = norm.NFC.String(parsed.Host)
if parsed.Host, err = idna.ToASCII(parsed.Host); err != nil {
return "", err
}
return NormalizeURL(parsed, f), nil
}
// NormalizeURL returns the normalized string.
// It takes a parsed URL object as input, as well as the normalization flags.
func NormalizeURL(u *url.URL, f NormalizationFlags) string {
for _, k := range flagsOrder {
if f&k == k {
flags[k](u)
}
}
return urlesc.Escape(u)
}
func lowercaseScheme(u *url.URL) {
if len(u.Scheme) > 0 {
u.Scheme = strings.ToLower(u.Scheme)
}
}
func lowercaseHost(u *url.URL) {
if len(u.Host) > 0 {
u.Host = strings.ToLower(u.Host)
}
}
func removeDefaultPort(u *url.URL) {
if len(u.Host) > 0 {
scheme := strings.ToLower(u.Scheme)
u.Host = rxPort.ReplaceAllStringFunc(u.Host, func(val string) string {
if (scheme == "http" && val == defaultHttpPort) || (scheme == "https" && val == defaultHttpsPort) {
return ""
}
return val
})
}
}
func removeTrailingSlash(u *url.URL) {
if l := len(u.Path); l > 0 {
if strings.HasSuffix(u.Path, "/") {
u.Path = u.Path[:l-1]
}
} else if l = len(u.Host); l > 0 {
if strings.HasSuffix(u.Host, "/") {
u.Host = u.Host[:l-1]
}
}
}
func addTrailingSlash(u *url.URL) {
if l := len(u.Path); l > 0 {
if !strings.HasSuffix(u.Path, "/") {
u.Path += "/"
}
} else if l = len(u.Host); l > 0 {
if !strings.HasSuffix(u.Host, "/") {
u.Host += "/"
}
}
}
func removeDotSegments(u *url.URL) {
if len(u.Path) > 0 {
var dotFree []string
var lastIsDot bool
sections := strings.Split(u.Path, "/")
for _, s := range sections {
if s == ".." {
if len(dotFree) > 0 {
dotFree = dotFree[:len(dotFree)-1]
}
} else if s != "." {
dotFree = append(dotFree, s)
}
lastIsDot = (s == "." || s == "..")
}
// Special case if host does not end with / and new path does not begin with /
u.Path = strings.Join(dotFree, "/")
if u.Host != "" && !strings.HasSuffix(u.Host, "/") && !strings.HasPrefix(u.Path, "/") {
u.Path = "/" + u.Path
}
// Special case if the last segment was a dot, make sure the path ends with a slash
if lastIsDot && !strings.HasSuffix(u.Path, "/") {
u.Path += "/"
}
}
}
func removeDirectoryIndex(u *url.URL) {
if len(u.Path) > 0 {
u.Path = rxDirIndex.ReplaceAllString(u.Path, "$1")
}
}
func removeFragment(u *url.URL) {
u.Fragment = ""
}
func forceHTTP(u *url.URL) {
if strings.ToLower(u.Scheme) == "https" {
u.Scheme = "http"
}
}
func removeDuplicateSlashes(u *url.URL) {
if len(u.Path) > 0 {
u.Path = rxDupSlashes.ReplaceAllString(u.Path, "/")
}
}
func removeWWW(u *url.URL) {
if len(u.Host) > 0 && strings.HasPrefix(strings.ToLower(u.Host), "www.") {
u.Host = u.Host[4:]
}
}
func addWWW(u *url.URL) {
if len(u.Host) > 0 && !strings.HasPrefix(strings.ToLower(u.Host), "www.") {
u.Host = "www." + u.Host
}
}
func sortQuery(u *url.URL) {
q := u.Query()
if len(q) > 0 {
arKeys := make([]string, len(q))
i := 0
for k := range q {
arKeys[i] = k
i++
}
sort.Strings(arKeys)
buf := new(bytes.Buffer)
for _, k := range arKeys {
sort.Strings(q[k])
for _, v := range q[k] {
if buf.Len() > 0 {
buf.WriteRune('&')
}
buf.WriteString(fmt.Sprintf("%s=%s", k, urlesc.QueryEscape(v)))
}
}
// Rebuild the raw query string
u.RawQuery = buf.String()
}
}
func decodeDWORDHost(u *url.URL) {
if len(u.Host) > 0 {
if matches := rxDWORDHost.FindStringSubmatch(u.Host); len(matches) > 2 {
var parts [4]int64
dword, _ := strconv.ParseInt(matches[1], 10, 0)
for i, shift := range []uint{24, 16, 8, 0} {
parts[i] = dword >> shift & 0xFF
}
u.Host = fmt.Sprintf("%d.%d.%d.%d%s", parts[0], parts[1], parts[2], parts[3], matches[2])
}
}
}
func decodeOctalHost(u *url.URL) {
if len(u.Host) > 0 {
if matches := rxOctalHost.FindStringSubmatch(u.Host); len(matches) > 5 {
var parts [4]int64
for i := 1; i <= 4; i++ {
parts[i-1], _ = strconv.ParseInt(matches[i], 8, 0)
}
u.Host = fmt.Sprintf("%d.%d.%d.%d%s", parts[0], parts[1], parts[2], parts[3], matches[5])
}
}
}
func decodeHexHost(u *url.URL) {
if len(u.Host) > 0 {
if matches := rxHexHost.FindStringSubmatch(u.Host); len(matches) > 2 {
// Conversion is safe because of regex validation
parsed, _ := strconv.ParseInt(matches[1], 16, 0)
// Set host as DWORD (base 10) encoded host
u.Host = fmt.Sprintf("%d%s", parsed, matches[2])
// The rest is the same as decoding a DWORD host
decodeDWORDHost(u)
}
}
}
func removeUnncessaryHostDots(u *url.URL) {
if len(u.Host) > 0 {
if matches := rxHostDots.FindStringSubmatch(u.Host); len(matches) > 1 {
// Trim the leading and trailing dots
u.Host = strings.Trim(matches[1], ".")
if len(matches) > 2 {
u.Host += matches[2]
}
}
}
}
func removeEmptyPortSeparator(u *url.URL) {
if len(u.Host) > 0 {
u.Host = rxEmptyPort.ReplaceAllString(u.Host, "")
}
}

View File

@ -1,15 +0,0 @@
language: go
go:
- 1.4.x
- 1.5.x
- 1.6.x
- 1.7.x
- 1.8.x
- tip
install:
- go build .
script:
- go test -v

View File

@ -1,27 +0,0 @@
Copyright (c) 2012 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
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
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 Inc. nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

View File

@ -1,16 +0,0 @@
urlesc [![Build Status](https://travis-ci.org/PuerkitoBio/urlesc.svg?branch=master)](https://travis-ci.org/PuerkitoBio/urlesc) [![GoDoc](http://godoc.org/github.com/PuerkitoBio/urlesc?status.svg)](http://godoc.org/github.com/PuerkitoBio/urlesc)
======
Package urlesc implements query escaping as per RFC 3986.
It contains some parts of the net/url package, modified so as to allow
some reserved characters incorrectly escaped by net/url (see [issue 5684](https://github.com/golang/go/issues/5684)).
## Install
go get github.com/PuerkitoBio/urlesc
## License
Go license (BSD-3-Clause)

View File

@ -1,180 +0,0 @@
// Copyright 2009 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 urlesc implements query escaping as per RFC 3986.
// It contains some parts of the net/url package, modified so as to allow
// some reserved characters incorrectly escaped by net/url.
// See https://github.com/golang/go/issues/5684
package urlesc
import (
"bytes"
"net/url"
"strings"
)
type encoding int
const (
encodePath encoding = 1 + iota
encodeUserPassword
encodeQueryComponent
encodeFragment
)
// Return true if the specified character should be escaped when
// appearing in a URL string, according to RFC 3986.
func shouldEscape(c byte, mode encoding) bool {
// §2.3 Unreserved characters (alphanum)
if 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' {
return false
}
switch c {
case '-', '.', '_', '~': // §2.3 Unreserved characters (mark)
return false
// §2.2 Reserved characters (reserved)
case ':', '/', '?', '#', '[', ']', '@', // gen-delims
'!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=': // sub-delims
// Different sections of the URL allow a few of
// the reserved characters to appear unescaped.
switch mode {
case encodePath: // §3.3
// The RFC allows sub-delims and : @.
// '/', '[' and ']' can be used to assign meaning to individual path
// segments. This package only manipulates the path as a whole,
// so we allow those as well. That leaves only ? and # to escape.
return c == '?' || c == '#'
case encodeUserPassword: // §3.2.1
// The RFC allows : and sub-delims in
// userinfo. The parsing of userinfo treats ':' as special so we must escape
// all the gen-delims.
return c == ':' || c == '/' || c == '?' || c == '#' || c == '[' || c == ']' || c == '@'
case encodeQueryComponent: // §3.4
// The RFC allows / and ?.
return c != '/' && c != '?'
case encodeFragment: // §4.1
// The RFC text is silent but the grammar allows
// everything, so escape nothing but #
return c == '#'
}
}
// Everything else must be escaped.
return true
}
// QueryEscape escapes the string so it can be safely placed
// inside a URL query.
func QueryEscape(s string) string {
return escape(s, encodeQueryComponent)
}
func escape(s string, mode encoding) string {
spaceCount, hexCount := 0, 0
for i := 0; i < len(s); i++ {
c := s[i]
if shouldEscape(c, mode) {
if c == ' ' && mode == encodeQueryComponent {
spaceCount++
} else {
hexCount++
}
}
}
if spaceCount == 0 && hexCount == 0 {
return s
}
t := make([]byte, len(s)+2*hexCount)
j := 0
for i := 0; i < len(s); i++ {
switch c := s[i]; {
case c == ' ' && mode == encodeQueryComponent:
t[j] = '+'
j++
case shouldEscape(c, mode):
t[j] = '%'
t[j+1] = "0123456789ABCDEF"[c>>4]
t[j+2] = "0123456789ABCDEF"[c&15]
j += 3
default:
t[j] = s[i]
j++
}
}
return string(t)
}
var uiReplacer = strings.NewReplacer(
"%21", "!",
"%27", "'",
"%28", "(",
"%29", ")",
"%2A", "*",
)
// unescapeUserinfo unescapes some characters that need not to be escaped as per RFC3986.
func unescapeUserinfo(s string) string {
return uiReplacer.Replace(s)
}
// Escape reassembles the URL into a valid URL string.
// The general form of the result is one of:
//
// scheme:opaque
// scheme://userinfo@host/path?query#fragment
//
// If u.Opaque is non-empty, String uses the first form;
// otherwise it uses the second form.
//
// In the second form, the following rules apply:
// - if u.Scheme is empty, scheme: is omitted.
// - if u.User is nil, userinfo@ is omitted.
// - if u.Host is empty, host/ is omitted.
// - if u.Scheme and u.Host are empty and u.User is nil,
// the entire scheme://userinfo@host/ is omitted.
// - if u.Host is non-empty and u.Path begins with a /,
// the form host/path does not add its own /.
// - if u.RawQuery is empty, ?query is omitted.
// - if u.Fragment is empty, #fragment is omitted.
func Escape(u *url.URL) string {
var buf bytes.Buffer
if u.Scheme != "" {
buf.WriteString(u.Scheme)
buf.WriteByte(':')
}
if u.Opaque != "" {
buf.WriteString(u.Opaque)
} else {
if u.Scheme != "" || u.Host != "" || u.User != nil {
buf.WriteString("//")
if ui := u.User; ui != nil {
buf.WriteString(unescapeUserinfo(ui.String()))
buf.WriteByte('@')
}
if h := u.Host; h != "" {
buf.WriteString(h)
}
}
if u.Path != "" && u.Path[0] != '/' && u.Host != "" {
buf.WriteByte('/')
}
buf.WriteString(escape(u.Path, encodePath))
}
if u.RawQuery != "" {
buf.WriteByte('?')
buf.WriteString(u.RawQuery)
}
if u.Fragment != "" {
buf.WriteByte('#')
buf.WriteString(escape(u.Fragment, encodeFragment))
}
return buf.String()
}

View File

@ -1,5 +1,9 @@
# Change history of go-restful # Change history of go-restful
## [v3.9.0] - 20221-07-21
- add support for http.Handler implementations to work as FilterFunction, issue #504 (thanks to https://github.com/ggicci)
## [v3.8.0] - 20221-06-06 ## [v3.8.0] - 20221-06-06
- use exact matching of allowed domain entries, issue #489 (#493) - use exact matching of allowed domain entries, issue #489 (#493)

View File

@ -84,6 +84,7 @@ func (u UserResource) findUser(request *restful.Request, response *restful.Respo
- Route errors produce HTTP 404/405/406/415 errors, customizable using ServiceErrorHandler(...) - Route errors produce HTTP 404/405/406/415 errors, customizable using ServiceErrorHandler(...)
- Configurable (trace) logging - Configurable (trace) logging
- Customizable gzip/deflate readers and writers using CompressorProvider registration - Customizable gzip/deflate readers and writers using CompressorProvider registration
- Inject your own http.Handler using the `HttpMiddlewareHandlerToFilter` function
## How to customize ## How to customize
There are several hooks to customize the behavior of the go-restful package. There are several hooks to customize the behavior of the go-restful package.
@ -94,7 +95,7 @@ There are several hooks to customize the behavior of the go-restful package.
- Trace logging - Trace logging
- Compression - Compression
- Encoders for other serializers - Encoders for other serializers
- Use [jsoniter](https://github.com/json-iterator/go) by build this package using a tag, e.g. `go build -tags=jsoniter .` - Use [jsoniter](https://github.com/json-iterator/go) by building this package using a build tag, e.g. `go build -tags=jsoniter .`
## Resources ## Resources

View File

@ -0,0 +1,21 @@
package restful
import (
"net/http"
)
// HttpMiddlewareHandler is a function that takes a http.Handler and returns a http.Handler
type HttpMiddlewareHandler func(http.Handler) http.Handler
// HttpMiddlewareHandlerToFilter converts a HttpMiddlewareHandler to a FilterFunction.
func HttpMiddlewareHandlerToFilter(middleware HttpMiddlewareHandler) FilterFunction {
return func(req *Request, resp *Response, chain *FilterChain) {
next := http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
req.Request = r
resp.ResponseWriter = rw
chain.ProcessFilter(req, resp)
})
middleware(next).ServeHTTP(resp.ResponseWriter, req.Request)
}
}

View File

@ -22,6 +22,9 @@ const (
// FormParameterKind = indicator of Request parameter type "form" // FormParameterKind = indicator of Request parameter type "form"
FormParameterKind FormParameterKind
// MultiPartFormParameterKind = indicator of Request parameter type "multipart/form-data"
MultiPartFormParameterKind
// CollectionFormatCSV comma separated values `foo,bar` // CollectionFormatCSV comma separated values `foo,bar`
CollectionFormatCSV = CollectionFormat("csv") CollectionFormatCSV = CollectionFormat("csv")
@ -108,6 +111,11 @@ func (p *Parameter) beForm() *Parameter {
return p return p
} }
func (p *Parameter) beMultiPartForm() *Parameter {
p.data.Kind = MultiPartFormParameterKind
return p
}
// Required sets the required field and returns the receiver // Required sets the required field and returns the receiver
func (p *Parameter) Required(required bool) *Parameter { func (p *Parameter) Required(required bool) *Parameter {
p.data.Required = required p.data.Required = required

View File

@ -165,6 +165,18 @@ func FormParameter(name, description string) *Parameter {
return p return p
} }
// MultiPartFormParameter creates a new Parameter of kind Form (using multipart/form-data) for documentation purposes.
// It is initialized as required with string as its DataType.
func (w *WebService) MultiPartFormParameter(name, description string) *Parameter {
return MultiPartFormParameter(name, description)
}
func MultiPartFormParameter(name, description string) *Parameter {
p := &Parameter{&ParameterData{Name: name, Description: description, Required: false, DataType: "string"}}
p.beMultiPartForm()
return p
}
// Route creates a new Route using the RouteBuilder and add to the ordered list of Routes. // Route creates a new Route using the RouteBuilder and add to the ordered list of Routes.
func (w *WebService) Route(builder *RouteBuilder) *WebService { func (w *WebService) Route(builder *RouteBuilder) *WebService {
w.routesLock.Lock() w.routesLock.Lock()

View File

@ -0,0 +1,63 @@
package internal
import (
"net/url"
"regexp"
"strings"
)
const (
defaultHttpPort = ":80"
defaultHttpsPort = ":443"
)
// Regular expressions used by the normalizations
var rxPort = regexp.MustCompile(`(:\d+)/?$`)
var rxDupSlashes = regexp.MustCompile(`/{2,}`)
// NormalizeURL will normalize the specified URL
// This was added to replace a previous call to the no longer maintained purell library:
// The call that was used looked like the following:
// url.Parse(purell.NormalizeURL(parsed, purell.FlagsSafe|purell.FlagRemoveDuplicateSlashes))
//
// To explain all that was included in the call above, purell.FlagsSafe was really just the following:
// - FlagLowercaseScheme
// - FlagLowercaseHost
// - FlagRemoveDefaultPort
// - FlagRemoveDuplicateSlashes (and this was mixed in with the |)
func NormalizeURL(u *url.URL) {
lowercaseScheme(u)
lowercaseHost(u)
removeDefaultPort(u)
removeDuplicateSlashes(u)
}
func lowercaseScheme(u *url.URL) {
if len(u.Scheme) > 0 {
u.Scheme = strings.ToLower(u.Scheme)
}
}
func lowercaseHost(u *url.URL) {
if len(u.Host) > 0 {
u.Host = strings.ToLower(u.Host)
}
}
func removeDefaultPort(u *url.URL) {
if len(u.Host) > 0 {
scheme := strings.ToLower(u.Scheme)
u.Host = rxPort.ReplaceAllStringFunc(u.Host, func(val string) string {
if (scheme == "http" && val == defaultHttpPort) || (scheme == "https" && val == defaultHttpsPort) {
return ""
}
return val
})
}
}
func removeDuplicateSlashes(u *url.URL) {
if len(u.Path) > 0 {
u.Path = rxDupSlashes.ReplaceAllString(u.Path, "/")
}
}

View File

@ -30,8 +30,8 @@ import (
"net/url" "net/url"
"strings" "strings"
"github.com/PuerkitoBio/purell"
"github.com/go-openapi/jsonpointer" "github.com/go-openapi/jsonpointer"
"github.com/go-openapi/jsonreference/internal"
) )
const ( const (
@ -114,7 +114,9 @@ func (r *Ref) parse(jsonReferenceString string) error {
return err return err
} }
r.referenceURL, _ = url.Parse(purell.NormalizeURL(parsed, purell.FlagsSafe|purell.FlagRemoveDuplicateSlashes)) internal.NormalizeURL(parsed)
r.referenceURL = parsed
refURL := r.referenceURL refURL := r.referenceURL
if refURL.Scheme != "" && refURL.Host != "" { if refURL.Scheme != "" && refURL.Host != "" {

2
vendor/github.com/go-openapi/swag/.gitattributes generated vendored Normal file
View File

@ -0,0 +1,2 @@
# gofmt always uses LF, whereas Git uses CRLF on Windows.
*.go text eol=lf

View File

@ -37,3 +37,18 @@ linters:
- gci - gci
- gocognit - gocognit
- paralleltest - paralleltest
- thelper
- ifshort
- gomoddirectives
- cyclop
- forcetypeassert
- ireturn
- tagliatelle
- varnamelen
- goimports
- tenv
- golint
- exhaustruct
- nilnil
- nonamedreturns
- nosnakecase

View File

@ -1,37 +0,0 @@
after_success:
- bash <(curl -s https://codecov.io/bash)
go:
- 1.14.x
- 1.x
arch:
- amd64
jobs:
include:
# include arch ppc, but only for latest go version - skip testing for race
- go: 1.x
arch: ppc64le
install: ~
script:
- go test -v
#- go: 1.x
# arch: arm
# install: ~
# script:
# - go test -v
# include linting job, but only for latest go version and amd64 arch
- go: 1.x
arch: amd64
install:
go get github.com/golangci/golangci-lint/cmd/golangci-lint
script:
- golangci-lint run --new-from-rev master
install:
- GO111MODULE=off go get -u gotest.tools/gotestsum
language: go
notifications:
slack:
secure: QUWvCkBBK09GF7YtEvHHVt70JOkdlNBG0nIKu/5qc4/nW5HP8I2w0SEf/XR2je0eED1Qe3L/AfMCWwrEj+IUZc3l4v+ju8X8R3Lomhme0Eb0jd1MTMCuPcBT47YCj0M7RON7vXtbFfm1hFJ/jLe5+9FXz0hpXsR24PJc5ZIi/ogNwkaPqG4BmndzecpSh0vc2FJPZUD9LT0I09REY/vXR0oQAalLkW0asGD5taHZTUZq/kBpsNxaAFrLM23i4mUcf33M5fjLpvx5LRICrX/57XpBrDh2TooBU6Qj3CgoY0uPRYUmSNxbVx1czNzl2JtEpb5yjoxfVPQeg0BvQM00G8LJINISR+ohrjhkZmAqchDupAX+yFrxTtORa78CtnIL6z/aTNlgwwVD8kvL/1pFA/JWYmKDmz93mV/+6wubGzNSQCstzjkFA4/iZEKewKUoRIAi/fxyscP6L/rCpmY/4llZZvrnyTqVbt6URWpopUpH4rwYqreXAtJxJsfBJIeSmUIiDIOMGkCTvyTEW3fWGmGoqWtSHLoaWDyAIGb7azb+KvfpWtEcoPFWfSWU+LGee0A/YsUhBl7ADB9A0CJEuR8q4BPpKpfLwPKSiKSAXL7zDkyjExyhtgqbSl2jS+rKIHOZNL8JkCcTP2MKMVd563C5rC5FMKqu3S9m2b6380E=
script:
- gotestsum -f short-verbose -- -race -coverprofile=coverage.txt -covermode=atomic ./...

View File

@ -17,16 +17,15 @@ Package swag contains a bunch of helper functions for go-openapi and go-swagger
You may also use it standalone for your projects. You may also use it standalone for your projects.
* convert between value and pointers for builtin types - convert between value and pointers for builtin types
* convert from string to builtin types (wraps strconv) - convert from string to builtin types (wraps strconv)
* fast json concatenation - fast json concatenation
* search in path - search in path
* load from file or http - load from file or http
* name mangling - name mangling
This repo has only few dependencies outside of the standard library: This repo has only few dependencies outside of the standard library:
* YAML utilities depend on gopkg.in/yaml.v2 - YAML utilities depend on gopkg.in/yaml.v2
*/ */
package swag package swag

33
vendor/github.com/go-openapi/swag/file.go generated vendored Normal file
View File

@ -0,0 +1,33 @@
// Copyright 2015 go-swagger maintainers
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package swag
import "mime/multipart"
// File represents an uploaded file.
type File struct {
Data multipart.File
Header *multipart.FileHeader
}
// Read bytes from the file
func (f *File) Read(p []byte) (n int, err error) {
return f.Data.Read(p)
}
// Close the file
func (f *File) Close() error {
return f.Data.Close()
}

View File

@ -16,10 +16,11 @@ package swag
import ( import (
"fmt" "fmt"
"io/ioutil" "io"
"log" "log"
"net/http" "net/http"
"net/url" "net/url"
"os"
"path/filepath" "path/filepath"
"runtime" "runtime"
"strings" "strings"
@ -40,13 +41,13 @@ var LoadHTTPCustomHeaders = map[string]string{}
// LoadFromFileOrHTTP loads the bytes from a file or a remote http server based on the path passed in // LoadFromFileOrHTTP loads the bytes from a file or a remote http server based on the path passed in
func LoadFromFileOrHTTP(path string) ([]byte, error) { func LoadFromFileOrHTTP(path string) ([]byte, error) {
return LoadStrategy(path, ioutil.ReadFile, loadHTTPBytes(LoadHTTPTimeout))(path) return LoadStrategy(path, os.ReadFile, loadHTTPBytes(LoadHTTPTimeout))(path)
} }
// LoadFromFileOrHTTPWithTimeout loads the bytes from a file or a remote http server based on the path passed in // LoadFromFileOrHTTPWithTimeout loads the bytes from a file or a remote http server based on the path passed in
// timeout arg allows for per request overriding of the request timeout // timeout arg allows for per request overriding of the request timeout
func LoadFromFileOrHTTPWithTimeout(path string, timeout time.Duration) ([]byte, error) { func LoadFromFileOrHTTPWithTimeout(path string, timeout time.Duration) ([]byte, error) {
return LoadStrategy(path, ioutil.ReadFile, loadHTTPBytes(timeout))(path) return LoadStrategy(path, os.ReadFile, loadHTTPBytes(timeout))(path)
} }
// LoadStrategy returns a loader function for a given path or uri // LoadStrategy returns a loader function for a given path or uri
@ -86,7 +87,7 @@ func LoadStrategy(path string, local, remote func(string) ([]byte, error)) func(
func loadHTTPBytes(timeout time.Duration) func(path string) ([]byte, error) { func loadHTTPBytes(timeout time.Duration) func(path string) ([]byte, error) {
return func(path string) ([]byte, error) { return func(path string) ([]byte, error) {
client := &http.Client{Timeout: timeout} client := &http.Client{Timeout: timeout}
req, err := http.NewRequest("GET", path, nil) // nolint: noctx req, err := http.NewRequest(http.MethodGet, path, nil) //nolint:noctx
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -115,6 +116,6 @@ func loadHTTPBytes(timeout time.Duration) func(path string) ([]byte, error) {
return nil, fmt.Errorf("could not access document at %q [%s] ", path, resp.Status) return nil, fmt.Errorf("could not access document at %q [%s] ", path, resp.Status)
} }
return ioutil.ReadAll(resp.Body) return io.ReadAll(resp.Body)
} }
} }

View File

@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
//go:build go1.8
// +build go1.8 // +build go1.8
package swag package swag

View File

@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
//go:build go1.9
// +build go1.9 // +build go1.9
package swag package swag

View File

@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
//go:build !go1.8
// +build !go1.8 // +build !go1.8
package swag package swag

View File

@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
//go:build !go1.9
// +build !go1.9 // +build !go1.9
package swag package swag

View File

@ -99,6 +99,7 @@ const (
) )
// JoinByFormat joins a string array by a known format (e.g. swagger's collectionFormat attribute): // JoinByFormat joins a string array by a known format (e.g. swagger's collectionFormat attribute):
//
// ssv: space separated value // ssv: space separated value
// tsv: tab separated value // tsv: tab separated value
// pipes: pipe (|) separated value // pipes: pipe (|) separated value
@ -124,11 +125,11 @@ func JoinByFormat(data []string, format string) []string {
} }
// SplitByFormat splits a string by a known format: // SplitByFormat splits a string by a known format:
//
// ssv: space separated value // ssv: space separated value
// tsv: tab separated value // tsv: tab separated value
// pipes: pipe (|) separated value // pipes: pipe (|) separated value
// csv: comma separated value (default) // csv: comma separated value (default)
//
func SplitByFormat(data, format string) []string { func SplitByFormat(data, format string) []string {
if data == "" { if data == "" {
return nil return nil

View File

@ -22,7 +22,7 @@ import (
"github.com/mailru/easyjson/jlexer" "github.com/mailru/easyjson/jlexer"
"github.com/mailru/easyjson/jwriter" "github.com/mailru/easyjson/jwriter"
yaml "gopkg.in/yaml.v2" yaml "gopkg.in/yaml.v3"
) )
// YAMLMatcher matches yaml // YAMLMatcher matches yaml
@ -43,16 +43,126 @@ func YAMLToJSON(data interface{}) (json.RawMessage, error) {
// BytesToYAMLDoc converts a byte slice into a YAML document // BytesToYAMLDoc converts a byte slice into a YAML document
func BytesToYAMLDoc(data []byte) (interface{}, error) { func BytesToYAMLDoc(data []byte) (interface{}, error) {
var canary map[interface{}]interface{} // validate this is an object and not a different type var document yaml.Node // preserve order that is present in the document
if err := yaml.Unmarshal(data, &canary); err != nil {
return nil, err
}
var document yaml.MapSlice // preserve order that is present in the document
if err := yaml.Unmarshal(data, &document); err != nil { if err := yaml.Unmarshal(data, &document); err != nil {
return nil, err return nil, err
} }
return document, nil if document.Kind != yaml.DocumentNode || len(document.Content) != 1 || document.Content[0].Kind != yaml.MappingNode {
return nil, fmt.Errorf("only YAML documents that are objects are supported")
}
return &document, nil
}
func yamlNode(root *yaml.Node) (interface{}, error) {
switch root.Kind {
case yaml.DocumentNode:
return yamlDocument(root)
case yaml.SequenceNode:
return yamlSequence(root)
case yaml.MappingNode:
return yamlMapping(root)
case yaml.ScalarNode:
return yamlScalar(root)
case yaml.AliasNode:
return yamlNode(root.Alias)
default:
return nil, fmt.Errorf("unsupported YAML node type: %v", root.Kind)
}
}
func yamlDocument(node *yaml.Node) (interface{}, error) {
if len(node.Content) != 1 {
return nil, fmt.Errorf("unexpected YAML Document node content length: %d", len(node.Content))
}
return yamlNode(node.Content[0])
}
func yamlMapping(node *yaml.Node) (interface{}, error) {
m := make(JSONMapSlice, len(node.Content)/2)
var j int
for i := 0; i < len(node.Content); i += 2 {
var nmi JSONMapItem
k, err := yamlStringScalarC(node.Content[i])
if err != nil {
return nil, fmt.Errorf("unable to decode YAML map key: %w", err)
}
nmi.Key = k
v, err := yamlNode(node.Content[i+1])
if err != nil {
return nil, fmt.Errorf("unable to process YAML map value for key %q: %w", k, err)
}
nmi.Value = v
m[j] = nmi
j++
}
return m, nil
}
func yamlSequence(node *yaml.Node) (interface{}, error) {
s := make([]interface{}, 0)
for i := 0; i < len(node.Content); i++ {
v, err := yamlNode(node.Content[i])
if err != nil {
return nil, fmt.Errorf("unable to decode YAML sequence value: %w", err)
}
s = append(s, v)
}
return s, nil
}
const ( // See https://yaml.org/type/
yamlStringScalar = "tag:yaml.org,2002:str"
yamlIntScalar = "tag:yaml.org,2002:int"
yamlBoolScalar = "tag:yaml.org,2002:bool"
yamlFloatScalar = "tag:yaml.org,2002:float"
yamlTimestamp = "tag:yaml.org,2002:timestamp"
yamlNull = "tag:yaml.org,2002:null"
)
func yamlScalar(node *yaml.Node) (interface{}, error) {
switch node.LongTag() {
case yamlStringScalar:
return node.Value, nil
case yamlBoolScalar:
b, err := strconv.ParseBool(node.Value)
if err != nil {
return nil, fmt.Errorf("unable to process scalar node. Got %q. Expecting bool content: %w", node.Value, err)
}
return b, nil
case yamlIntScalar:
i, err := strconv.ParseInt(node.Value, 10, 64)
if err != nil {
return nil, fmt.Errorf("unable to process scalar node. Got %q. Expecting integer content: %w", node.Value, err)
}
return i, nil
case yamlFloatScalar:
f, err := strconv.ParseFloat(node.Value, 64)
if err != nil {
return nil, fmt.Errorf("unable to process scalar node. Got %q. Expecting float content: %w", node.Value, err)
}
return f, nil
case yamlTimestamp:
return node.Value, nil
case yamlNull:
return nil, nil
default:
return nil, fmt.Errorf("YAML tag %q is not supported", node.LongTag())
}
}
func yamlStringScalarC(node *yaml.Node) (string, error) {
if node.Kind != yaml.ScalarNode {
return "", fmt.Errorf("expecting a string scalar but got %q", node.Kind)
}
switch node.LongTag() {
case yamlStringScalar, yamlIntScalar, yamlFloatScalar:
return node.Value, nil
default:
return "", fmt.Errorf("YAML tag %q is not supported as map key", node.LongTag())
}
} }
// JSONMapSlice represent a JSON object, with the order of keys maintained // JSONMapSlice represent a JSON object, with the order of keys maintained
@ -105,6 +215,113 @@ func (s *JSONMapSlice) UnmarshalEasyJSON(in *jlexer.Lexer) {
*s = result *s = result
} }
func (s JSONMapSlice) MarshalYAML() (interface{}, error) {
var n yaml.Node
n.Kind = yaml.DocumentNode
var nodes []*yaml.Node
for _, item := range s {
nn, err := json2yaml(item.Value)
if err != nil {
return nil, err
}
ns := []*yaml.Node{
{
Kind: yaml.ScalarNode,
Tag: yamlStringScalar,
Value: item.Key,
},
nn,
}
nodes = append(nodes, ns...)
}
n.Content = []*yaml.Node{
{
Kind: yaml.MappingNode,
Content: nodes,
},
}
return yaml.Marshal(&n)
}
func json2yaml(item interface{}) (*yaml.Node, error) {
switch val := item.(type) {
case JSONMapSlice:
var n yaml.Node
n.Kind = yaml.MappingNode
for i := range val {
childNode, err := json2yaml(&val[i].Value)
if err != nil {
return nil, err
}
n.Content = append(n.Content, &yaml.Node{
Kind: yaml.ScalarNode,
Tag: yamlStringScalar,
Value: val[i].Key,
}, childNode)
}
return &n, nil
case map[string]interface{}:
var n yaml.Node
n.Kind = yaml.MappingNode
for k, v := range val {
childNode, err := json2yaml(v)
if err != nil {
return nil, err
}
n.Content = append(n.Content, &yaml.Node{
Kind: yaml.ScalarNode,
Tag: yamlStringScalar,
Value: k,
}, childNode)
}
return &n, nil
case []interface{}:
var n yaml.Node
n.Kind = yaml.SequenceNode
for i := range val {
childNode, err := json2yaml(val[i])
if err != nil {
return nil, err
}
n.Content = append(n.Content, childNode)
}
return &n, nil
case string:
return &yaml.Node{
Kind: yaml.ScalarNode,
Tag: yamlStringScalar,
Value: val,
}, nil
case float64:
return &yaml.Node{
Kind: yaml.ScalarNode,
Tag: yamlFloatScalar,
Value: strconv.FormatFloat(val, 'f', -1, 64),
}, nil
case int64:
return &yaml.Node{
Kind: yaml.ScalarNode,
Tag: yamlIntScalar,
Value: strconv.FormatInt(val, 10),
}, nil
case uint64:
return &yaml.Node{
Kind: yaml.ScalarNode,
Tag: yamlIntScalar,
Value: strconv.FormatUint(val, 10),
}, nil
case bool:
return &yaml.Node{
Kind: yaml.ScalarNode,
Tag: yamlBoolScalar,
Value: strconv.FormatBool(val),
}, nil
}
return nil, nil
}
// JSONMapItem represents the value of a key in a JSON object held by JSONMapSlice // JSONMapItem represents the value of a key in a JSON object held by JSONMapSlice
type JSONMapItem struct { type JSONMapItem struct {
Key string Key string
@ -173,23 +390,10 @@ func transformData(input interface{}) (out interface{}, err error) {
} }
switch in := input.(type) { switch in := input.(type) {
case yaml.MapSlice: case yaml.Node:
return yamlNode(&in)
o := make(JSONMapSlice, len(in)) case *yaml.Node:
for i, mi := range in { return yamlNode(in)
var nmi JSONMapItem
if nmi.Key, err = format(mi.Key); err != nil {
return nil, err
}
v, ert := transformData(mi.Value)
if ert != nil {
return nil, ert
}
nmi.Value = v
o[i] = nmi
}
return o, nil
case map[interface{}]interface{}: case map[interface{}]interface{}:
o := make(JSONMapSlice, 0, len(in)) o := make(JSONMapSlice, 0, len(in))
for ke, va := range in { for ke, va := range in {

View File

@ -46,8 +46,23 @@ func (schema *Schema) describeSchema(indent string) string {
if schema.Schema != nil { if schema.Schema != nil {
result += indent + "$schema: " + *(schema.Schema) + "\n" result += indent + "$schema: " + *(schema.Schema) + "\n"
} }
if schema.ReadOnly != nil && *schema.ReadOnly {
result += indent + fmt.Sprintf("readOnly: %+v\n", *(schema.ReadOnly))
}
if schema.WriteOnly != nil && *schema.WriteOnly {
result += indent + fmt.Sprintf("writeOnly: %+v\n", *(schema.WriteOnly))
}
if schema.ID != nil { if schema.ID != nil {
switch strings.TrimSuffix(*schema.Schema, "#") {
case "http://json-schema.org/draft-04/schema#":
fallthrough
case "#":
fallthrough
case "":
result += indent + "id: " + *(schema.ID) + "\n" result += indent + "id: " + *(schema.ID) + "\n"
default:
result += indent + "$id: " + *(schema.ID) + "\n"
}
} }
if schema.MultipleOf != nil { if schema.MultipleOf != nil {
result += indent + fmt.Sprintf("multipleOf: %+v\n", *(schema.MultipleOf)) result += indent + fmt.Sprintf("multipleOf: %+v\n", *(schema.MultipleOf))

View File

@ -26,6 +26,8 @@ type Schema struct {
Schema *string // $schema Schema *string // $schema
ID *string // id keyword used for $ref resolution scope ID *string // id keyword used for $ref resolution scope
Ref *string // $ref, i.e. JSON Pointers Ref *string // $ref, i.e. JSON Pointers
ReadOnly *bool
WriteOnly *bool
// http://json-schema.org/latest/json-schema-validation.html // http://json-schema.org/latest/json-schema-validation.html
// 5.1. Validation keywords for numeric instances (number and integer) // 5.1. Validation keywords for numeric instances (number and integer)

View File

@ -165,7 +165,6 @@ func NewSchemaFromObject(jsonData *yaml.Node) *Schema {
default: default:
fmt.Printf("schemaValue: unexpected node %+v\n", jsonData) fmt.Printf("schemaValue: unexpected node %+v\n", jsonData)
return nil
} }
return nil return nil

View File

@ -16,6 +16,7 @@ package jsonschema
import ( import (
"fmt" "fmt"
"strings"
"gopkg.in/yaml.v3" "gopkg.in/yaml.v3"
) )
@ -33,7 +34,11 @@ func renderMappingNode(node *yaml.Node, indent string) (result string) {
value := node.Content[i+1] value := node.Content[i+1]
switch value.Kind { switch value.Kind {
case yaml.ScalarNode: case yaml.ScalarNode:
if value.Tag == "!!bool" {
result += value.Value
} else {
result += "\"" + value.Value + "\"" result += "\"" + value.Value + "\""
}
case yaml.MappingNode: case yaml.MappingNode:
result += renderMappingNode(value, innerIndent) result += renderMappingNode(value, innerIndent)
case yaml.SequenceNode: case yaml.SequenceNode:
@ -58,7 +63,11 @@ func renderSequenceNode(node *yaml.Node, indent string) (result string) {
item := node.Content[i] item := node.Content[i]
switch item.Kind { switch item.Kind {
case yaml.ScalarNode: case yaml.ScalarNode:
if item.Tag == "!!bool" {
result += innerIndent + item.Value
} else {
result += innerIndent + "\"" + item.Value + "\"" result += innerIndent + "\"" + item.Value + "\""
}
case yaml.MappingNode: case yaml.MappingNode:
result += innerIndent + renderMappingNode(item, innerIndent) + "" result += innerIndent + renderMappingNode(item, innerIndent) + ""
default: default:
@ -260,11 +269,26 @@ func (schema *Schema) nodeValue() *yaml.Node {
content = appendPair(content, "title", nodeForString(*schema.Title)) content = appendPair(content, "title", nodeForString(*schema.Title))
} }
if schema.ID != nil { if schema.ID != nil {
switch strings.TrimSuffix(*schema.Schema, "#") {
case "http://json-schema.org/draft-04/schema":
fallthrough
case "#":
fallthrough
case "":
content = appendPair(content, "id", nodeForString(*schema.ID)) content = appendPair(content, "id", nodeForString(*schema.ID))
default:
content = appendPair(content, "$id", nodeForString(*schema.ID))
}
} }
if schema.Schema != nil { if schema.Schema != nil {
content = appendPair(content, "$schema", nodeForString(*schema.Schema)) content = appendPair(content, "$schema", nodeForString(*schema.Schema))
} }
if schema.ReadOnly != nil && *schema.ReadOnly {
content = appendPair(content, "readOnly", nodeForBoolean(*schema.ReadOnly))
}
if schema.WriteOnly != nil && *schema.WriteOnly {
content = appendPair(content, "writeOnly", nodeForBoolean(*schema.WriteOnly))
}
if schema.Type != nil { if schema.Type != nil {
content = appendPair(content, "type", schema.Type.nodeValue()) content = appendPair(content, "type", schema.Type.nodeValue())
} }

View File

@ -7887,7 +7887,12 @@ func (m *Oauth2Scopes) ToRawInfo() *yaml.Node {
if m == nil { if m == nil {
return info return info
} }
// &{Name:additionalProperties Type:NamedString StringEnumValues:[] MapType:string Repeated:true Pattern: Implicit:true Description:} if m.AdditionalProperties != nil {
for _, item := range m.AdditionalProperties {
info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Value))
}
}
return info return info
} }

View File

@ -8560,7 +8560,12 @@ func (m *Strings) ToRawInfo() *yaml.Node {
if m == nil { if m == nil {
return info return info
} }
// &{Name:additionalProperties Type:NamedString StringEnumValues:[] MapType:string Repeated:true Pattern: Implicit:true Description:} if m.AdditionalProperties != nil {
for _, item := range m.AdditionalProperties {
info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Value))
}
}
return info return info
} }

View File

@ -16,8 +16,8 @@
// Code generated by protoc-gen-go. DO NOT EDIT. // Code generated by protoc-gen-go. DO NOT EDIT.
// versions: // versions:
// protoc-gen-go v1.26.0 // protoc-gen-go v1.28.0
// protoc v3.18.1 // protoc v3.19.4
// source: openapiv3/OpenAPIv3.proto // source: openapiv3/OpenAPIv3.proto
package openapi_v3 package openapi_v3
@ -6760,12 +6760,13 @@ var file_openapiv3_OpenAPIv3_proto_rawDesc = []byte{
0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b,
0x32, 0x14, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x33, 0x2e, 0x4e, 0x61, 0x32, 0x14, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x33, 0x2e, 0x4e, 0x61,
0x6d, 0x65, 0x64, 0x41, 0x6e, 0x79, 0x52, 0x16, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x6d, 0x65, 0x64, 0x41, 0x6e, 0x79, 0x52, 0x16, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63,
0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x3e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x56,
0x0a, 0x0e, 0x6f, 0x72, 0x67, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x33, 0x0a, 0x0e, 0x6f, 0x72, 0x67, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x33,
0x42, 0x0c, 0x4f, 0x70, 0x65, 0x6e, 0x41, 0x50, 0x49, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x42, 0x0c, 0x4f, 0x70, 0x65, 0x6e, 0x41, 0x50, 0x49, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01,
0x5a, 0x16, 0x2e, 0x2f, 0x6f, 0x70, 0x65, 0x6e, 0x61, 0x70, 0x69, 0x76, 0x33, 0x3b, 0x6f, 0x70, 0x5a, 0x2e, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6f,
0x65, 0x6e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x33, 0xa2, 0x02, 0x03, 0x4f, 0x41, 0x53, 0x62, 0x06, 0x67, 0x6c, 0x65, 0x2f, 0x67, 0x6e, 0x6f, 0x73, 0x74, 0x69, 0x63, 0x2f, 0x6f, 0x70, 0x65, 0x6e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x61, 0x70, 0x69, 0x76, 0x33, 0x3b, 0x6f, 0x70, 0x65, 0x6e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x33,
0xa2, 0x02, 0x03, 0x4f, 0x41, 0x53, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
} }
var ( var (

View File

@ -42,7 +42,7 @@ option java_package = "org.openapi_v3";
option objc_class_prefix = "OAS"; option objc_class_prefix = "OAS";
// The Go package name. // The Go package name.
option go_package = "./openapiv3;openapi_v3"; option go_package = "github.com/google/gnostic/openapiv3;openapi_v3";
message AdditionalPropertiesItem { message AdditionalPropertiesItem {
oneof oneof { oneof oneof {

View File

@ -19,3 +19,7 @@ for OpenAPI.
The schema-generator directory contains support code which generates The schema-generator directory contains support code which generates
openapi-3.1.json from the OpenAPI 3.1 specification document (Markdown). openapi-3.1.json from the OpenAPI 3.1 specification document (Markdown).
### How to rebuild
`protoc -I=. -I=third_party --go_out=. --go_opt=paths=source_relative openapiv3/*.proto`

View File

@ -0,0 +1,183 @@
// Copyright 2022 Google LLC. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.28.0
// protoc v3.19.4
// source: openapiv3/annotations.proto
package openapi_v3
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
descriptorpb "google.golang.org/protobuf/types/descriptorpb"
reflect "reflect"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
var file_openapiv3_annotations_proto_extTypes = []protoimpl.ExtensionInfo{
{
ExtendedType: (*descriptorpb.FileOptions)(nil),
ExtensionType: (*Document)(nil),
Field: 1143,
Name: "openapi.v3.document",
Tag: "bytes,1143,opt,name=document",
Filename: "openapiv3/annotations.proto",
},
{
ExtendedType: (*descriptorpb.MethodOptions)(nil),
ExtensionType: (*Operation)(nil),
Field: 1143,
Name: "openapi.v3.operation",
Tag: "bytes,1143,opt,name=operation",
Filename: "openapiv3/annotations.proto",
},
{
ExtendedType: (*descriptorpb.MessageOptions)(nil),
ExtensionType: (*Schema)(nil),
Field: 1143,
Name: "openapi.v3.schema",
Tag: "bytes,1143,opt,name=schema",
Filename: "openapiv3/annotations.proto",
},
{
ExtendedType: (*descriptorpb.FieldOptions)(nil),
ExtensionType: (*Schema)(nil),
Field: 1143,
Name: "openapi.v3.property",
Tag: "bytes,1143,opt,name=property",
Filename: "openapiv3/annotations.proto",
},
}
// Extension fields to descriptorpb.FileOptions.
var (
// optional openapi.v3.Document document = 1143;
E_Document = &file_openapiv3_annotations_proto_extTypes[0]
)
// Extension fields to descriptorpb.MethodOptions.
var (
// optional openapi.v3.Operation operation = 1143;
E_Operation = &file_openapiv3_annotations_proto_extTypes[1]
)
// Extension fields to descriptorpb.MessageOptions.
var (
// optional openapi.v3.Schema schema = 1143;
E_Schema = &file_openapiv3_annotations_proto_extTypes[2]
)
// Extension fields to descriptorpb.FieldOptions.
var (
// optional openapi.v3.Schema property = 1143;
E_Property = &file_openapiv3_annotations_proto_extTypes[3]
)
var File_openapiv3_annotations_proto protoreflect.FileDescriptor
var file_openapiv3_annotations_proto_rawDesc = []byte{
0x0a, 0x1b, 0x6f, 0x70, 0x65, 0x6e, 0x61, 0x70, 0x69, 0x76, 0x33, 0x2f, 0x61, 0x6e, 0x6e, 0x6f,
0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0a, 0x6f,
0x70, 0x65, 0x6e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x33, 0x1a, 0x19, 0x6f, 0x70, 0x65, 0x6e, 0x61,
0x70, 0x69, 0x76, 0x33, 0x2f, 0x4f, 0x70, 0x65, 0x6e, 0x41, 0x50, 0x49, 0x76, 0x33, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x3a, 0x4f, 0x0a, 0x08, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65,
0x6e, 0x74, 0x12, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
0x18, 0xf7, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x61, 0x70,
0x69, 0x2e, 0x76, 0x33, 0x2e, 0x44, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x08, 0x64,
0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x3a, 0x54, 0x0a, 0x09, 0x6f, 0x70, 0x65, 0x72, 0x61,
0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x18, 0xf7, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6f, 0x70,
0x65, 0x6e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x33, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69,
0x6f, 0x6e, 0x52, 0x09, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x4c, 0x0a,
0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xf7, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x12, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x33, 0x2e, 0x53, 0x63, 0x68,
0x65, 0x6d, 0x61, 0x52, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x3a, 0x4e, 0x0a, 0x08, 0x70,
0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x12, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f,
0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xf7, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e,
0x6f, 0x70, 0x65, 0x6e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x33, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d,
0x61, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x42, 0x5a, 0x0a, 0x0e, 0x6f,
0x72, 0x67, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x61, 0x70, 0x69, 0x5f, 0x76, 0x33, 0x42, 0x10, 0x41,
0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50,
0x01, 0x5a, 0x2e, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f,
0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x67, 0x6e, 0x6f, 0x73, 0x74, 0x69, 0x63, 0x2f, 0x6f, 0x70, 0x65,
0x6e, 0x61, 0x70, 0x69, 0x76, 0x33, 0x3b, 0x6f, 0x70, 0x65, 0x6e, 0x61, 0x70, 0x69, 0x5f, 0x76,
0x33, 0xa2, 0x02, 0x03, 0x4f, 0x41, 0x53, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var file_openapiv3_annotations_proto_goTypes = []interface{}{
(*descriptorpb.FileOptions)(nil), // 0: google.protobuf.FileOptions
(*descriptorpb.MethodOptions)(nil), // 1: google.protobuf.MethodOptions
(*descriptorpb.MessageOptions)(nil), // 2: google.protobuf.MessageOptions
(*descriptorpb.FieldOptions)(nil), // 3: google.protobuf.FieldOptions
(*Document)(nil), // 4: openapi.v3.Document
(*Operation)(nil), // 5: openapi.v3.Operation
(*Schema)(nil), // 6: openapi.v3.Schema
}
var file_openapiv3_annotations_proto_depIdxs = []int32{
0, // 0: openapi.v3.document:extendee -> google.protobuf.FileOptions
1, // 1: openapi.v3.operation:extendee -> google.protobuf.MethodOptions
2, // 2: openapi.v3.schema:extendee -> google.protobuf.MessageOptions
3, // 3: openapi.v3.property:extendee -> google.protobuf.FieldOptions
4, // 4: openapi.v3.document:type_name -> openapi.v3.Document
5, // 5: openapi.v3.operation:type_name -> openapi.v3.Operation
6, // 6: openapi.v3.schema:type_name -> openapi.v3.Schema
6, // 7: openapi.v3.property:type_name -> openapi.v3.Schema
8, // [8:8] is the sub-list for method output_type
8, // [8:8] is the sub-list for method input_type
4, // [4:8] is the sub-list for extension type_name
0, // [0:4] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_openapiv3_annotations_proto_init() }
func file_openapiv3_annotations_proto_init() {
if File_openapiv3_annotations_proto != nil {
return
}
file_openapiv3_OpenAPIv3_proto_init()
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_openapiv3_annotations_proto_rawDesc,
NumEnums: 0,
NumMessages: 0,
NumExtensions: 4,
NumServices: 0,
},
GoTypes: file_openapiv3_annotations_proto_goTypes,
DependencyIndexes: file_openapiv3_annotations_proto_depIdxs,
ExtensionInfos: file_openapiv3_annotations_proto_extTypes,
}.Build()
File_openapiv3_annotations_proto = out.File
file_openapiv3_annotations_proto_rawDesc = nil
file_openapiv3_annotations_proto_goTypes = nil
file_openapiv3_annotations_proto_depIdxs = nil
}

View File

@ -0,0 +1,60 @@
// Copyright 2022 Google LLC. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
syntax = "proto3";
package openapi.v3;
import "openapiv3/OpenAPIv3.proto";
import "google/protobuf/descriptor.proto";
// This option lets the proto compiler generate Java code inside the package
// name (see below) instead of inside an outer class. It creates a simpler
// developer experience by reducing one-level of name nesting and be
// consistent with most programming languages that don't support outer classes.
option java_multiple_files = true;
// The Java outer classname should be the filename in UpperCamelCase. This
// class is only used to hold proto descriptor, so developers don't need to
// work with it directly.
option java_outer_classname = "AnnotationsProto";
// The Java package name must be proto package name with proper prefix.
option java_package = "org.openapi_v3";
// A reasonable prefix for the Objective-C symbols generated from the package.
// It should at a minimum be 3 characters long, all uppercase, and convention
// is to use an abbreviation of the package name. Something short, but
// hopefully unique enough to not conflict with things that may come along in
// the future. 'GPB' is reserved for the protocol buffer implementation itself.
option objc_class_prefix = "OAS";
// The Go package name.
option go_package = "github.com/google/gnostic/openapiv3;openapi_v3";
extend google.protobuf.FileOptions {
Document document = 1143;
}
extend google.protobuf.MethodOptions {
Operation operation = 1143;
}
extend google.protobuf.MessageOptions {
Schema schema = 1143;
}
extend google.protobuf.FieldOptions {
Schema property = 1143;
}

View File

@ -401,6 +401,7 @@ func (r *Lexer) scanToken() {
// consume resets the current token to allow scanning the next one. // consume resets the current token to allow scanning the next one.
func (r *Lexer) consume() { func (r *Lexer) consume() {
r.token.kind = tokenUndef r.token.kind = tokenUndef
r.token.byteValueCloned = false
r.token.delimValue = 0 r.token.delimValue = 0
} }
@ -528,6 +529,7 @@ func (r *Lexer) Skip() {
func (r *Lexer) SkipRecursive() { func (r *Lexer) SkipRecursive() {
r.scanToken() r.scanToken()
var start, end byte var start, end byte
startPos := r.start
switch r.token.delimValue { switch r.token.delimValue {
case '{': case '{':
@ -553,6 +555,14 @@ func (r *Lexer) SkipRecursive() {
level-- level--
if level == 0 { if level == 0 {
r.pos += i + 1 r.pos += i + 1
if !json.Valid(r.Data[startPos:r.pos]) {
r.pos = len(r.Data)
r.fatalError = &LexerError{
Reason: "skipped array/object json value is invalid",
Offset: r.pos,
Data: string(r.Data[r.pos:]),
}
}
return return
} }
case c == '\\' && inQuotes: case c == '\\' && inQuotes:
@ -702,6 +712,10 @@ func (r *Lexer) Bytes() []byte {
r.errInvalidToken("string") r.errInvalidToken("string")
return nil return nil
} }
if err := r.unescapeStringToken(); err != nil {
r.errInvalidToken("string")
return nil
}
ret := make([]byte, base64.StdEncoding.DecodedLen(len(r.token.byteValue))) ret := make([]byte, base64.StdEncoding.DecodedLen(len(r.token.byteValue)))
n, err := base64.StdEncoding.Decode(ret, r.token.byteValue) n, err := base64.StdEncoding.Decode(ret, r.token.byteValue)
if err != nil { if err != nil {

View File

@ -1,28 +0,0 @@
// Code generated by "stringer -type=Kind"; DO NOT EDIT.
package width
import "strconv"
func _() {
// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
var x [1]struct{}
_ = x[Neutral-0]
_ = x[EastAsianAmbiguous-1]
_ = x[EastAsianWide-2]
_ = x[EastAsianNarrow-3]
_ = x[EastAsianFullwidth-4]
_ = x[EastAsianHalfwidth-5]
}
const _Kind_name = "NeutralEastAsianAmbiguousEastAsianWideEastAsianNarrowEastAsianFullwidthEastAsianHalfwidth"
var _Kind_index = [...]uint8{0, 7, 25, 38, 53, 71, 89}
func (i Kind) String() string {
if i < 0 || i >= Kind(len(_Kind_index)-1) {
return "Kind(" + strconv.FormatInt(int64(i), 10) + ")"
}
return _Kind_name[_Kind_index[i]:_Kind_index[i+1]]
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -1,239 +0,0 @@
// Copyright 2015 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 width
import (
"unicode/utf8"
"golang.org/x/text/transform"
)
type foldTransform struct {
transform.NopResetter
}
func (foldTransform) Span(src []byte, atEOF bool) (n int, err error) {
for n < len(src) {
if src[n] < utf8.RuneSelf {
// ASCII fast path.
for n++; n < len(src) && src[n] < utf8.RuneSelf; n++ {
}
continue
}
v, size := trie.lookup(src[n:])
if size == 0 { // incomplete UTF-8 encoding
if !atEOF {
err = transform.ErrShortSrc
} else {
n = len(src)
}
break
}
if elem(v)&tagNeedsFold != 0 {
err = transform.ErrEndOfSpan
break
}
n += size
}
return n, err
}
func (foldTransform) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
for nSrc < len(src) {
if src[nSrc] < utf8.RuneSelf {
// ASCII fast path.
start, end := nSrc, len(src)
if d := len(dst) - nDst; d < end-start {
end = nSrc + d
}
for nSrc++; nSrc < end && src[nSrc] < utf8.RuneSelf; nSrc++ {
}
n := copy(dst[nDst:], src[start:nSrc])
if nDst += n; nDst == len(dst) {
nSrc = start + n
if nSrc == len(src) {
return nDst, nSrc, nil
}
if src[nSrc] < utf8.RuneSelf {
return nDst, nSrc, transform.ErrShortDst
}
}
continue
}
v, size := trie.lookup(src[nSrc:])
if size == 0 { // incomplete UTF-8 encoding
if !atEOF {
return nDst, nSrc, transform.ErrShortSrc
}
size = 1 // gobble 1 byte
}
if elem(v)&tagNeedsFold == 0 {
if size != copy(dst[nDst:], src[nSrc:nSrc+size]) {
return nDst, nSrc, transform.ErrShortDst
}
nDst += size
} else {
data := inverseData[byte(v)]
if len(dst)-nDst < int(data[0]) {
return nDst, nSrc, transform.ErrShortDst
}
i := 1
for end := int(data[0]); i < end; i++ {
dst[nDst] = data[i]
nDst++
}
dst[nDst] = data[i] ^ src[nSrc+size-1]
nDst++
}
nSrc += size
}
return nDst, nSrc, nil
}
type narrowTransform struct {
transform.NopResetter
}
func (narrowTransform) Span(src []byte, atEOF bool) (n int, err error) {
for n < len(src) {
if src[n] < utf8.RuneSelf {
// ASCII fast path.
for n++; n < len(src) && src[n] < utf8.RuneSelf; n++ {
}
continue
}
v, size := trie.lookup(src[n:])
if size == 0 { // incomplete UTF-8 encoding
if !atEOF {
err = transform.ErrShortSrc
} else {
n = len(src)
}
break
}
if k := elem(v).kind(); byte(v) == 0 || k != EastAsianFullwidth && k != EastAsianWide && k != EastAsianAmbiguous {
} else {
err = transform.ErrEndOfSpan
break
}
n += size
}
return n, err
}
func (narrowTransform) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
for nSrc < len(src) {
if src[nSrc] < utf8.RuneSelf {
// ASCII fast path.
start, end := nSrc, len(src)
if d := len(dst) - nDst; d < end-start {
end = nSrc + d
}
for nSrc++; nSrc < end && src[nSrc] < utf8.RuneSelf; nSrc++ {
}
n := copy(dst[nDst:], src[start:nSrc])
if nDst += n; nDst == len(dst) {
nSrc = start + n
if nSrc == len(src) {
return nDst, nSrc, nil
}
if src[nSrc] < utf8.RuneSelf {
return nDst, nSrc, transform.ErrShortDst
}
}
continue
}
v, size := trie.lookup(src[nSrc:])
if size == 0 { // incomplete UTF-8 encoding
if !atEOF {
return nDst, nSrc, transform.ErrShortSrc
}
size = 1 // gobble 1 byte
}
if k := elem(v).kind(); byte(v) == 0 || k != EastAsianFullwidth && k != EastAsianWide && k != EastAsianAmbiguous {
if size != copy(dst[nDst:], src[nSrc:nSrc+size]) {
return nDst, nSrc, transform.ErrShortDst
}
nDst += size
} else {
data := inverseData[byte(v)]
if len(dst)-nDst < int(data[0]) {
return nDst, nSrc, transform.ErrShortDst
}
i := 1
for end := int(data[0]); i < end; i++ {
dst[nDst] = data[i]
nDst++
}
dst[nDst] = data[i] ^ src[nSrc+size-1]
nDst++
}
nSrc += size
}
return nDst, nSrc, nil
}
type wideTransform struct {
transform.NopResetter
}
func (wideTransform) Span(src []byte, atEOF bool) (n int, err error) {
for n < len(src) {
// TODO: Consider ASCII fast path. Special-casing ASCII handling can
// reduce the ns/op of BenchmarkWideASCII by about 30%. This is probably
// not enough to warrant the extra code and complexity.
v, size := trie.lookup(src[n:])
if size == 0 { // incomplete UTF-8 encoding
if !atEOF {
err = transform.ErrShortSrc
} else {
n = len(src)
}
break
}
if k := elem(v).kind(); byte(v) == 0 || k != EastAsianHalfwidth && k != EastAsianNarrow {
} else {
err = transform.ErrEndOfSpan
break
}
n += size
}
return n, err
}
func (wideTransform) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
for nSrc < len(src) {
// TODO: Consider ASCII fast path. Special-casing ASCII handling can
// reduce the ns/op of BenchmarkWideASCII by about 30%. This is probably
// not enough to warrant the extra code and complexity.
v, size := trie.lookup(src[nSrc:])
if size == 0 { // incomplete UTF-8 encoding
if !atEOF {
return nDst, nSrc, transform.ErrShortSrc
}
size = 1 // gobble 1 byte
}
if k := elem(v).kind(); byte(v) == 0 || k != EastAsianHalfwidth && k != EastAsianNarrow {
if size != copy(dst[nDst:], src[nSrc:nSrc+size]) {
return nDst, nSrc, transform.ErrShortDst
}
nDst += size
} else {
data := inverseData[byte(v)]
if len(dst)-nDst < int(data[0]) {
return nDst, nSrc, transform.ErrShortDst
}
i := 1
for end := int(data[0]); i < end; i++ {
dst[nDst] = data[i]
nDst++
}
dst[nDst] = data[i] ^ src[nSrc+size-1]
nDst++
}
nSrc += size
}
return nDst, nSrc, nil
}

View File

@ -1,30 +0,0 @@
// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
package width
// elem is an entry of the width trie. The high byte is used to encode the type
// of the rune. The low byte is used to store the index to a mapping entry in
// the inverseData array.
type elem uint16
const (
tagNeutral elem = iota << typeShift
tagAmbiguous
tagWide
tagNarrow
tagFullwidth
tagHalfwidth
)
const (
numTypeBits = 3
typeShift = 16 - numTypeBits
// tagNeedsFold is true for all fullwidth and halfwidth runes except for
// the Won sign U+20A9.
tagNeedsFold = 0x1000
// The Korean Won sign is halfwidth, but SHOULD NOT be mapped to a wide
// variant.
wonSign rune = 0x20A9
)

View File

@ -1,206 +0,0 @@
// Copyright 2015 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:generate stringer -type=Kind
//go:generate go run gen.go gen_common.go gen_trieval.go
// Package width provides functionality for handling different widths in text.
//
// Wide characters behave like ideographs; they tend to allow line breaks after
// each character and remain upright in vertical text layout. Narrow characters
// are kept together in words or runs that are rotated sideways in vertical text
// layout.
//
// For more information, see https://unicode.org/reports/tr11/.
package width // import "golang.org/x/text/width"
import (
"unicode/utf8"
"golang.org/x/text/transform"
)
// TODO
// 1) Reduce table size by compressing blocks.
// 2) API proposition for computing display length
// (approximation, fixed pitch only).
// 3) Implement display length.
// Kind indicates the type of width property as defined in https://unicode.org/reports/tr11/.
type Kind int
const (
// Neutral characters do not occur in legacy East Asian character sets.
Neutral Kind = iota
// EastAsianAmbiguous characters that can be sometimes wide and sometimes
// narrow and require additional information not contained in the character
// code to further resolve their width.
EastAsianAmbiguous
// EastAsianWide characters are wide in its usual form. They occur only in
// the context of East Asian typography. These runes may have explicit
// halfwidth counterparts.
EastAsianWide
// EastAsianNarrow characters are narrow in its usual form. They often have
// fullwidth counterparts.
EastAsianNarrow
// Note: there exist Narrow runes that do not have fullwidth or wide
// counterparts, despite what the definition says (e.g. U+27E6).
// EastAsianFullwidth characters have a compatibility decompositions of type
// wide that map to a narrow counterpart.
EastAsianFullwidth
// EastAsianHalfwidth characters have a compatibility decomposition of type
// narrow that map to a wide or ambiguous counterpart, plus U+20A9 ₩ WON
// SIGN.
EastAsianHalfwidth
// Note: there exist runes that have a halfwidth counterparts but that are
// classified as Ambiguous, rather than wide (e.g. U+2190).
)
// TODO: the generated tries need to return size 1 for invalid runes for the
// width to be computed correctly (each byte should render width 1)
var trie = newWidthTrie(0)
// Lookup reports the Properties of the first rune in b and the number of bytes
// of its UTF-8 encoding.
func Lookup(b []byte) (p Properties, size int) {
v, sz := trie.lookup(b)
return Properties{elem(v), b[sz-1]}, sz
}
// LookupString reports the Properties of the first rune in s and the number of
// bytes of its UTF-8 encoding.
func LookupString(s string) (p Properties, size int) {
v, sz := trie.lookupString(s)
return Properties{elem(v), s[sz-1]}, sz
}
// LookupRune reports the Properties of rune r.
func LookupRune(r rune) Properties {
var buf [4]byte
n := utf8.EncodeRune(buf[:], r)
v, _ := trie.lookup(buf[:n])
last := byte(r)
if r >= utf8.RuneSelf {
last = 0x80 + byte(r&0x3f)
}
return Properties{elem(v), last}
}
// Properties provides access to width properties of a rune.
type Properties struct {
elem elem
last byte
}
func (e elem) kind() Kind {
return Kind(e >> typeShift)
}
// Kind returns the Kind of a rune as defined in Unicode TR #11.
// See https://unicode.org/reports/tr11/ for more details.
func (p Properties) Kind() Kind {
return p.elem.kind()
}
// Folded returns the folded variant of a rune or 0 if the rune is canonical.
func (p Properties) Folded() rune {
if p.elem&tagNeedsFold != 0 {
buf := inverseData[byte(p.elem)]
buf[buf[0]] ^= p.last
r, _ := utf8.DecodeRune(buf[1 : 1+buf[0]])
return r
}
return 0
}
// Narrow returns the narrow variant of a rune or 0 if the rune is already
// narrow or doesn't have a narrow variant.
func (p Properties) Narrow() rune {
if k := p.elem.kind(); byte(p.elem) != 0 && (k == EastAsianFullwidth || k == EastAsianWide || k == EastAsianAmbiguous) {
buf := inverseData[byte(p.elem)]
buf[buf[0]] ^= p.last
r, _ := utf8.DecodeRune(buf[1 : 1+buf[0]])
return r
}
return 0
}
// Wide returns the wide variant of a rune or 0 if the rune is already
// wide or doesn't have a wide variant.
func (p Properties) Wide() rune {
if k := p.elem.kind(); byte(p.elem) != 0 && (k == EastAsianHalfwidth || k == EastAsianNarrow) {
buf := inverseData[byte(p.elem)]
buf[buf[0]] ^= p.last
r, _ := utf8.DecodeRune(buf[1 : 1+buf[0]])
return r
}
return 0
}
// TODO for Properties:
// - Add Fullwidth/Halfwidth or Inverted methods for computing variants
// mapping.
// - Add width information (including information on non-spacing runes).
// Transformer implements the transform.Transformer interface.
type Transformer struct {
t transform.SpanningTransformer
}
// Reset implements the transform.Transformer interface.
func (t Transformer) Reset() { t.t.Reset() }
// Transform implements the transform.Transformer interface.
func (t Transformer) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
return t.t.Transform(dst, src, atEOF)
}
// Span implements the transform.SpanningTransformer interface.
func (t Transformer) Span(src []byte, atEOF bool) (n int, err error) {
return t.t.Span(src, atEOF)
}
// Bytes returns a new byte slice with the result of applying t to b.
func (t Transformer) Bytes(b []byte) []byte {
b, _, _ = transform.Bytes(t, b)
return b
}
// String returns a string with the result of applying t to s.
func (t Transformer) String(s string) string {
s, _, _ = transform.String(t, s)
return s
}
var (
// Fold is a transform that maps all runes to their canonical width.
//
// Note that the NFKC and NFKD transforms in golang.org/x/text/unicode/norm
// provide a more generic folding mechanism.
Fold Transformer = Transformer{foldTransform{}}
// Widen is a transform that maps runes to their wide variant, if
// available.
Widen Transformer = Transformer{wideTransform{}}
// Narrow is a transform that maps runes to their narrow variant, if
// available.
Narrow Transformer = Transformer{narrowTransform{}}
)
// TODO: Consider the following options:
// - Treat Ambiguous runes that have a halfwidth counterpart as wide, or some
// generalized variant of this.
// - Consider a wide Won character to be the default width (or some generalized
// variant of this).
// - Filter the set of characters that gets converted (the preferred approach is
// to allow applying filters to transforms).

View File

@ -1,3 +0,0 @@
# This source code refers to The Go Authors for copyright purposes.
# The master list of authors is in the main Go distribution,
# visible at https://tip.golang.org/AUTHORS.

View File

@ -1,3 +0,0 @@
# This source code was written by the Go contributors.
# The master list of contributors is in the main Go distribution,
# visible at https://tip.golang.org/CONTRIBUTORS.

View File

@ -19,7 +19,7 @@ import (
"google.golang.org/protobuf/internal/pragma" "google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/internal/set" "google.golang.org/protobuf/internal/set"
"google.golang.org/protobuf/proto" "google.golang.org/protobuf/proto"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry" "google.golang.org/protobuf/reflect/protoregistry"
) )
@ -113,7 +113,7 @@ func (d decoder) syntaxError(pos int, f string, x ...interface{}) error {
} }
// unmarshalMessage unmarshals a message into the given protoreflect.Message. // unmarshalMessage unmarshals a message into the given protoreflect.Message.
func (d decoder) unmarshalMessage(m pref.Message, skipTypeURL bool) error { func (d decoder) unmarshalMessage(m protoreflect.Message, skipTypeURL bool) error {
if unmarshal := wellKnownTypeUnmarshaler(m.Descriptor().FullName()); unmarshal != nil { if unmarshal := wellKnownTypeUnmarshaler(m.Descriptor().FullName()); unmarshal != nil {
return unmarshal(d, m) return unmarshal(d, m)
} }
@ -159,10 +159,10 @@ func (d decoder) unmarshalMessage(m pref.Message, skipTypeURL bool) error {
} }
// Get the FieldDescriptor. // Get the FieldDescriptor.
var fd pref.FieldDescriptor var fd protoreflect.FieldDescriptor
if strings.HasPrefix(name, "[") && strings.HasSuffix(name, "]") { if strings.HasPrefix(name, "[") && strings.HasSuffix(name, "]") {
// Only extension names are in [name] format. // Only extension names are in [name] format.
extName := pref.FullName(name[1 : len(name)-1]) extName := protoreflect.FullName(name[1 : len(name)-1])
extType, err := d.opts.Resolver.FindExtensionByName(extName) extType, err := d.opts.Resolver.FindExtensionByName(extName)
if err != nil && err != protoregistry.NotFound { if err != nil && err != protoregistry.NotFound {
return d.newError(tok.Pos(), "unable to resolve %s: %v", tok.RawString(), err) return d.newError(tok.Pos(), "unable to resolve %s: %v", tok.RawString(), err)
@ -240,23 +240,23 @@ func (d decoder) unmarshalMessage(m pref.Message, skipTypeURL bool) error {
} }
} }
func isKnownValue(fd pref.FieldDescriptor) bool { func isKnownValue(fd protoreflect.FieldDescriptor) bool {
md := fd.Message() md := fd.Message()
return md != nil && md.FullName() == genid.Value_message_fullname return md != nil && md.FullName() == genid.Value_message_fullname
} }
func isNullValue(fd pref.FieldDescriptor) bool { func isNullValue(fd protoreflect.FieldDescriptor) bool {
ed := fd.Enum() ed := fd.Enum()
return ed != nil && ed.FullName() == genid.NullValue_enum_fullname return ed != nil && ed.FullName() == genid.NullValue_enum_fullname
} }
// unmarshalSingular unmarshals to the non-repeated field specified // unmarshalSingular unmarshals to the non-repeated field specified
// by the given FieldDescriptor. // by the given FieldDescriptor.
func (d decoder) unmarshalSingular(m pref.Message, fd pref.FieldDescriptor) error { func (d decoder) unmarshalSingular(m protoreflect.Message, fd protoreflect.FieldDescriptor) error {
var val pref.Value var val protoreflect.Value
var err error var err error
switch fd.Kind() { switch fd.Kind() {
case pref.MessageKind, pref.GroupKind: case protoreflect.MessageKind, protoreflect.GroupKind:
val = m.NewField(fd) val = m.NewField(fd)
err = d.unmarshalMessage(val.Message(), false) err = d.unmarshalMessage(val.Message(), false)
default: default:
@ -272,63 +272,63 @@ func (d decoder) unmarshalSingular(m pref.Message, fd pref.FieldDescriptor) erro
// unmarshalScalar unmarshals to a scalar/enum protoreflect.Value specified by // unmarshalScalar unmarshals to a scalar/enum protoreflect.Value specified by
// the given FieldDescriptor. // the given FieldDescriptor.
func (d decoder) unmarshalScalar(fd pref.FieldDescriptor) (pref.Value, error) { func (d decoder) unmarshalScalar(fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
const b32 int = 32 const b32 int = 32
const b64 int = 64 const b64 int = 64
tok, err := d.Read() tok, err := d.Read()
if err != nil { if err != nil {
return pref.Value{}, err return protoreflect.Value{}, err
} }
kind := fd.Kind() kind := fd.Kind()
switch kind { switch kind {
case pref.BoolKind: case protoreflect.BoolKind:
if tok.Kind() == json.Bool { if tok.Kind() == json.Bool {
return pref.ValueOfBool(tok.Bool()), nil return protoreflect.ValueOfBool(tok.Bool()), nil
} }
case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind: case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
if v, ok := unmarshalInt(tok, b32); ok { if v, ok := unmarshalInt(tok, b32); ok {
return v, nil return v, nil
} }
case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind: case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
if v, ok := unmarshalInt(tok, b64); ok { if v, ok := unmarshalInt(tok, b64); ok {
return v, nil return v, nil
} }
case pref.Uint32Kind, pref.Fixed32Kind: case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
if v, ok := unmarshalUint(tok, b32); ok { if v, ok := unmarshalUint(tok, b32); ok {
return v, nil return v, nil
} }
case pref.Uint64Kind, pref.Fixed64Kind: case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
if v, ok := unmarshalUint(tok, b64); ok { if v, ok := unmarshalUint(tok, b64); ok {
return v, nil return v, nil
} }
case pref.FloatKind: case protoreflect.FloatKind:
if v, ok := unmarshalFloat(tok, b32); ok { if v, ok := unmarshalFloat(tok, b32); ok {
return v, nil return v, nil
} }
case pref.DoubleKind: case protoreflect.DoubleKind:
if v, ok := unmarshalFloat(tok, b64); ok { if v, ok := unmarshalFloat(tok, b64); ok {
return v, nil return v, nil
} }
case pref.StringKind: case protoreflect.StringKind:
if tok.Kind() == json.String { if tok.Kind() == json.String {
return pref.ValueOfString(tok.ParsedString()), nil return protoreflect.ValueOfString(tok.ParsedString()), nil
} }
case pref.BytesKind: case protoreflect.BytesKind:
if v, ok := unmarshalBytes(tok); ok { if v, ok := unmarshalBytes(tok); ok {
return v, nil return v, nil
} }
case pref.EnumKind: case protoreflect.EnumKind:
if v, ok := unmarshalEnum(tok, fd); ok { if v, ok := unmarshalEnum(tok, fd); ok {
return v, nil return v, nil
} }
@ -337,10 +337,10 @@ func (d decoder) unmarshalScalar(fd pref.FieldDescriptor) (pref.Value, error) {
panic(fmt.Sprintf("unmarshalScalar: invalid scalar kind %v", kind)) panic(fmt.Sprintf("unmarshalScalar: invalid scalar kind %v", kind))
} }
return pref.Value{}, d.newError(tok.Pos(), "invalid value for %v type: %v", kind, tok.RawString()) return protoreflect.Value{}, d.newError(tok.Pos(), "invalid value for %v type: %v", kind, tok.RawString())
} }
func unmarshalInt(tok json.Token, bitSize int) (pref.Value, bool) { func unmarshalInt(tok json.Token, bitSize int) (protoreflect.Value, bool) {
switch tok.Kind() { switch tok.Kind() {
case json.Number: case json.Number:
return getInt(tok, bitSize) return getInt(tok, bitSize)
@ -349,30 +349,30 @@ func unmarshalInt(tok json.Token, bitSize int) (pref.Value, bool) {
// Decode number from string. // Decode number from string.
s := strings.TrimSpace(tok.ParsedString()) s := strings.TrimSpace(tok.ParsedString())
if len(s) != len(tok.ParsedString()) { if len(s) != len(tok.ParsedString()) {
return pref.Value{}, false return protoreflect.Value{}, false
} }
dec := json.NewDecoder([]byte(s)) dec := json.NewDecoder([]byte(s))
tok, err := dec.Read() tok, err := dec.Read()
if err != nil { if err != nil {
return pref.Value{}, false return protoreflect.Value{}, false
} }
return getInt(tok, bitSize) return getInt(tok, bitSize)
} }
return pref.Value{}, false return protoreflect.Value{}, false
} }
func getInt(tok json.Token, bitSize int) (pref.Value, bool) { func getInt(tok json.Token, bitSize int) (protoreflect.Value, bool) {
n, ok := tok.Int(bitSize) n, ok := tok.Int(bitSize)
if !ok { if !ok {
return pref.Value{}, false return protoreflect.Value{}, false
} }
if bitSize == 32 { if bitSize == 32 {
return pref.ValueOfInt32(int32(n)), true return protoreflect.ValueOfInt32(int32(n)), true
} }
return pref.ValueOfInt64(n), true return protoreflect.ValueOfInt64(n), true
} }
func unmarshalUint(tok json.Token, bitSize int) (pref.Value, bool) { func unmarshalUint(tok json.Token, bitSize int) (protoreflect.Value, bool) {
switch tok.Kind() { switch tok.Kind() {
case json.Number: case json.Number:
return getUint(tok, bitSize) return getUint(tok, bitSize)
@ -381,30 +381,30 @@ func unmarshalUint(tok json.Token, bitSize int) (pref.Value, bool) {
// Decode number from string. // Decode number from string.
s := strings.TrimSpace(tok.ParsedString()) s := strings.TrimSpace(tok.ParsedString())
if len(s) != len(tok.ParsedString()) { if len(s) != len(tok.ParsedString()) {
return pref.Value{}, false return protoreflect.Value{}, false
} }
dec := json.NewDecoder([]byte(s)) dec := json.NewDecoder([]byte(s))
tok, err := dec.Read() tok, err := dec.Read()
if err != nil { if err != nil {
return pref.Value{}, false return protoreflect.Value{}, false
} }
return getUint(tok, bitSize) return getUint(tok, bitSize)
} }
return pref.Value{}, false return protoreflect.Value{}, false
} }
func getUint(tok json.Token, bitSize int) (pref.Value, bool) { func getUint(tok json.Token, bitSize int) (protoreflect.Value, bool) {
n, ok := tok.Uint(bitSize) n, ok := tok.Uint(bitSize)
if !ok { if !ok {
return pref.Value{}, false return protoreflect.Value{}, false
} }
if bitSize == 32 { if bitSize == 32 {
return pref.ValueOfUint32(uint32(n)), true return protoreflect.ValueOfUint32(uint32(n)), true
} }
return pref.ValueOfUint64(n), true return protoreflect.ValueOfUint64(n), true
} }
func unmarshalFloat(tok json.Token, bitSize int) (pref.Value, bool) { func unmarshalFloat(tok json.Token, bitSize int) (protoreflect.Value, bool) {
switch tok.Kind() { switch tok.Kind() {
case json.Number: case json.Number:
return getFloat(tok, bitSize) return getFloat(tok, bitSize)
@ -414,49 +414,49 @@ func unmarshalFloat(tok json.Token, bitSize int) (pref.Value, bool) {
switch s { switch s {
case "NaN": case "NaN":
if bitSize == 32 { if bitSize == 32 {
return pref.ValueOfFloat32(float32(math.NaN())), true return protoreflect.ValueOfFloat32(float32(math.NaN())), true
} }
return pref.ValueOfFloat64(math.NaN()), true return protoreflect.ValueOfFloat64(math.NaN()), true
case "Infinity": case "Infinity":
if bitSize == 32 { if bitSize == 32 {
return pref.ValueOfFloat32(float32(math.Inf(+1))), true return protoreflect.ValueOfFloat32(float32(math.Inf(+1))), true
} }
return pref.ValueOfFloat64(math.Inf(+1)), true return protoreflect.ValueOfFloat64(math.Inf(+1)), true
case "-Infinity": case "-Infinity":
if bitSize == 32 { if bitSize == 32 {
return pref.ValueOfFloat32(float32(math.Inf(-1))), true return protoreflect.ValueOfFloat32(float32(math.Inf(-1))), true
} }
return pref.ValueOfFloat64(math.Inf(-1)), true return protoreflect.ValueOfFloat64(math.Inf(-1)), true
} }
// Decode number from string. // Decode number from string.
if len(s) != len(strings.TrimSpace(s)) { if len(s) != len(strings.TrimSpace(s)) {
return pref.Value{}, false return protoreflect.Value{}, false
} }
dec := json.NewDecoder([]byte(s)) dec := json.NewDecoder([]byte(s))
tok, err := dec.Read() tok, err := dec.Read()
if err != nil { if err != nil {
return pref.Value{}, false return protoreflect.Value{}, false
} }
return getFloat(tok, bitSize) return getFloat(tok, bitSize)
} }
return pref.Value{}, false return protoreflect.Value{}, false
} }
func getFloat(tok json.Token, bitSize int) (pref.Value, bool) { func getFloat(tok json.Token, bitSize int) (protoreflect.Value, bool) {
n, ok := tok.Float(bitSize) n, ok := tok.Float(bitSize)
if !ok { if !ok {
return pref.Value{}, false return protoreflect.Value{}, false
} }
if bitSize == 32 { if bitSize == 32 {
return pref.ValueOfFloat32(float32(n)), true return protoreflect.ValueOfFloat32(float32(n)), true
} }
return pref.ValueOfFloat64(n), true return protoreflect.ValueOfFloat64(n), true
} }
func unmarshalBytes(tok json.Token) (pref.Value, bool) { func unmarshalBytes(tok json.Token) (protoreflect.Value, bool) {
if tok.Kind() != json.String { if tok.Kind() != json.String {
return pref.Value{}, false return protoreflect.Value{}, false
} }
s := tok.ParsedString() s := tok.ParsedString()
@ -469,36 +469,36 @@ func unmarshalBytes(tok json.Token) (pref.Value, bool) {
} }
b, err := enc.DecodeString(s) b, err := enc.DecodeString(s)
if err != nil { if err != nil {
return pref.Value{}, false return protoreflect.Value{}, false
} }
return pref.ValueOfBytes(b), true return protoreflect.ValueOfBytes(b), true
} }
func unmarshalEnum(tok json.Token, fd pref.FieldDescriptor) (pref.Value, bool) { func unmarshalEnum(tok json.Token, fd protoreflect.FieldDescriptor) (protoreflect.Value, bool) {
switch tok.Kind() { switch tok.Kind() {
case json.String: case json.String:
// Lookup EnumNumber based on name. // Lookup EnumNumber based on name.
s := tok.ParsedString() s := tok.ParsedString()
if enumVal := fd.Enum().Values().ByName(pref.Name(s)); enumVal != nil { if enumVal := fd.Enum().Values().ByName(protoreflect.Name(s)); enumVal != nil {
return pref.ValueOfEnum(enumVal.Number()), true return protoreflect.ValueOfEnum(enumVal.Number()), true
} }
case json.Number: case json.Number:
if n, ok := tok.Int(32); ok { if n, ok := tok.Int(32); ok {
return pref.ValueOfEnum(pref.EnumNumber(n)), true return protoreflect.ValueOfEnum(protoreflect.EnumNumber(n)), true
} }
case json.Null: case json.Null:
// This is only valid for google.protobuf.NullValue. // This is only valid for google.protobuf.NullValue.
if isNullValue(fd) { if isNullValue(fd) {
return pref.ValueOfEnum(0), true return protoreflect.ValueOfEnum(0), true
} }
} }
return pref.Value{}, false return protoreflect.Value{}, false
} }
func (d decoder) unmarshalList(list pref.List, fd pref.FieldDescriptor) error { func (d decoder) unmarshalList(list protoreflect.List, fd protoreflect.FieldDescriptor) error {
tok, err := d.Read() tok, err := d.Read()
if err != nil { if err != nil {
return err return err
@ -508,7 +508,7 @@ func (d decoder) unmarshalList(list pref.List, fd pref.FieldDescriptor) error {
} }
switch fd.Kind() { switch fd.Kind() {
case pref.MessageKind, pref.GroupKind: case protoreflect.MessageKind, protoreflect.GroupKind:
for { for {
tok, err := d.Peek() tok, err := d.Peek()
if err != nil { if err != nil {
@ -549,7 +549,7 @@ func (d decoder) unmarshalList(list pref.List, fd pref.FieldDescriptor) error {
return nil return nil
} }
func (d decoder) unmarshalMap(mmap pref.Map, fd pref.FieldDescriptor) error { func (d decoder) unmarshalMap(mmap protoreflect.Map, fd protoreflect.FieldDescriptor) error {
tok, err := d.Read() tok, err := d.Read()
if err != nil { if err != nil {
return err return err
@ -561,18 +561,18 @@ func (d decoder) unmarshalMap(mmap pref.Map, fd pref.FieldDescriptor) error {
// Determine ahead whether map entry is a scalar type or a message type in // Determine ahead whether map entry is a scalar type or a message type in
// order to call the appropriate unmarshalMapValue func inside the for loop // order to call the appropriate unmarshalMapValue func inside the for loop
// below. // below.
var unmarshalMapValue func() (pref.Value, error) var unmarshalMapValue func() (protoreflect.Value, error)
switch fd.MapValue().Kind() { switch fd.MapValue().Kind() {
case pref.MessageKind, pref.GroupKind: case protoreflect.MessageKind, protoreflect.GroupKind:
unmarshalMapValue = func() (pref.Value, error) { unmarshalMapValue = func() (protoreflect.Value, error) {
val := mmap.NewValue() val := mmap.NewValue()
if err := d.unmarshalMessage(val.Message(), false); err != nil { if err := d.unmarshalMessage(val.Message(), false); err != nil {
return pref.Value{}, err return protoreflect.Value{}, err
} }
return val, nil return val, nil
} }
default: default:
unmarshalMapValue = func() (pref.Value, error) { unmarshalMapValue = func() (protoreflect.Value, error) {
return d.unmarshalScalar(fd.MapValue()) return d.unmarshalScalar(fd.MapValue())
} }
} }
@ -618,7 +618,7 @@ Loop:
// unmarshalMapKey converts given token of Name kind into a protoreflect.MapKey. // unmarshalMapKey converts given token of Name kind into a protoreflect.MapKey.
// A map key type is any integral or string type. // A map key type is any integral or string type.
func (d decoder) unmarshalMapKey(tok json.Token, fd pref.FieldDescriptor) (pref.MapKey, error) { func (d decoder) unmarshalMapKey(tok json.Token, fd protoreflect.FieldDescriptor) (protoreflect.MapKey, error) {
const b32 = 32 const b32 = 32
const b64 = 64 const b64 = 64
const base10 = 10 const base10 = 10
@ -626,40 +626,40 @@ func (d decoder) unmarshalMapKey(tok json.Token, fd pref.FieldDescriptor) (pref.
name := tok.Name() name := tok.Name()
kind := fd.Kind() kind := fd.Kind()
switch kind { switch kind {
case pref.StringKind: case protoreflect.StringKind:
return pref.ValueOfString(name).MapKey(), nil return protoreflect.ValueOfString(name).MapKey(), nil
case pref.BoolKind: case protoreflect.BoolKind:
switch name { switch name {
case "true": case "true":
return pref.ValueOfBool(true).MapKey(), nil return protoreflect.ValueOfBool(true).MapKey(), nil
case "false": case "false":
return pref.ValueOfBool(false).MapKey(), nil return protoreflect.ValueOfBool(false).MapKey(), nil
} }
case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind: case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
if n, err := strconv.ParseInt(name, base10, b32); err == nil { if n, err := strconv.ParseInt(name, base10, b32); err == nil {
return pref.ValueOfInt32(int32(n)).MapKey(), nil return protoreflect.ValueOfInt32(int32(n)).MapKey(), nil
} }
case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind: case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
if n, err := strconv.ParseInt(name, base10, b64); err == nil { if n, err := strconv.ParseInt(name, base10, b64); err == nil {
return pref.ValueOfInt64(int64(n)).MapKey(), nil return protoreflect.ValueOfInt64(int64(n)).MapKey(), nil
} }
case pref.Uint32Kind, pref.Fixed32Kind: case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
if n, err := strconv.ParseUint(name, base10, b32); err == nil { if n, err := strconv.ParseUint(name, base10, b32); err == nil {
return pref.ValueOfUint32(uint32(n)).MapKey(), nil return protoreflect.ValueOfUint32(uint32(n)).MapKey(), nil
} }
case pref.Uint64Kind, pref.Fixed64Kind: case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
if n, err := strconv.ParseUint(name, base10, b64); err == nil { if n, err := strconv.ParseUint(name, base10, b64); err == nil {
return pref.ValueOfUint64(uint64(n)).MapKey(), nil return protoreflect.ValueOfUint64(uint64(n)).MapKey(), nil
} }
default: default:
panic(fmt.Sprintf("invalid kind for map key: %v", kind)) panic(fmt.Sprintf("invalid kind for map key: %v", kind))
} }
return pref.MapKey{}, d.newError(tok.Pos(), "invalid value for %v key: %s", kind, tok.RawString()) return protoreflect.MapKey{}, d.newError(tok.Pos(), "invalid value for %v key: %s", kind, tok.RawString())
} }

View File

@ -18,7 +18,6 @@ import (
"google.golang.org/protobuf/internal/pragma" "google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/proto" "google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry" "google.golang.org/protobuf/reflect/protoregistry"
) )
@ -164,8 +163,8 @@ type typeURLFieldRanger struct {
typeURL string typeURL string
} }
func (m typeURLFieldRanger) Range(f func(pref.FieldDescriptor, pref.Value) bool) { func (m typeURLFieldRanger) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
if !f(typeFieldDesc, pref.ValueOfString(m.typeURL)) { if !f(typeFieldDesc, protoreflect.ValueOfString(m.typeURL)) {
return return
} }
m.FieldRanger.Range(f) m.FieldRanger.Range(f)
@ -173,9 +172,9 @@ func (m typeURLFieldRanger) Range(f func(pref.FieldDescriptor, pref.Value) bool)
// unpopulatedFieldRanger wraps a protoreflect.Message and modifies its Range // unpopulatedFieldRanger wraps a protoreflect.Message and modifies its Range
// method to additionally iterate over unpopulated fields. // method to additionally iterate over unpopulated fields.
type unpopulatedFieldRanger struct{ pref.Message } type unpopulatedFieldRanger struct{ protoreflect.Message }
func (m unpopulatedFieldRanger) Range(f func(pref.FieldDescriptor, pref.Value) bool) { func (m unpopulatedFieldRanger) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
fds := m.Descriptor().Fields() fds := m.Descriptor().Fields()
for i := 0; i < fds.Len(); i++ { for i := 0; i < fds.Len(); i++ {
fd := fds.Get(i) fd := fds.Get(i)
@ -184,10 +183,10 @@ func (m unpopulatedFieldRanger) Range(f func(pref.FieldDescriptor, pref.Value) b
} }
v := m.Get(fd) v := m.Get(fd)
isProto2Scalar := fd.Syntax() == pref.Proto2 && fd.Default().IsValid() isProto2Scalar := fd.Syntax() == protoreflect.Proto2 && fd.Default().IsValid()
isSingularMessage := fd.Cardinality() != pref.Repeated && fd.Message() != nil isSingularMessage := fd.Cardinality() != protoreflect.Repeated && fd.Message() != nil
if isProto2Scalar || isSingularMessage { if isProto2Scalar || isSingularMessage {
v = pref.Value{} // use invalid value to emit null v = protoreflect.Value{} // use invalid value to emit null
} }
if !f(fd, v) { if !f(fd, v) {
return return
@ -199,7 +198,7 @@ func (m unpopulatedFieldRanger) Range(f func(pref.FieldDescriptor, pref.Value) b
// marshalMessage marshals the fields in the given protoreflect.Message. // marshalMessage marshals the fields in the given protoreflect.Message.
// If the typeURL is non-empty, then a synthetic "@type" field is injected // If the typeURL is non-empty, then a synthetic "@type" field is injected
// containing the URL as the value. // containing the URL as the value.
func (e encoder) marshalMessage(m pref.Message, typeURL string) error { func (e encoder) marshalMessage(m protoreflect.Message, typeURL string) error {
if !flags.ProtoLegacy && messageset.IsMessageSet(m.Descriptor()) { if !flags.ProtoLegacy && messageset.IsMessageSet(m.Descriptor()) {
return errors.New("no support for proto1 MessageSets") return errors.New("no support for proto1 MessageSets")
} }
@ -220,7 +219,7 @@ func (e encoder) marshalMessage(m pref.Message, typeURL string) error {
} }
var err error var err error
order.RangeFields(fields, order.IndexNameFieldOrder, func(fd pref.FieldDescriptor, v pref.Value) bool { order.RangeFields(fields, order.IndexNameFieldOrder, func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
name := fd.JSONName() name := fd.JSONName()
if e.opts.UseProtoNames { if e.opts.UseProtoNames {
name = fd.TextName() name = fd.TextName()
@ -238,7 +237,7 @@ func (e encoder) marshalMessage(m pref.Message, typeURL string) error {
} }
// marshalValue marshals the given protoreflect.Value. // marshalValue marshals the given protoreflect.Value.
func (e encoder) marshalValue(val pref.Value, fd pref.FieldDescriptor) error { func (e encoder) marshalValue(val protoreflect.Value, fd protoreflect.FieldDescriptor) error {
switch { switch {
case fd.IsList(): case fd.IsList():
return e.marshalList(val.List(), fd) return e.marshalList(val.List(), fd)
@ -251,44 +250,44 @@ func (e encoder) marshalValue(val pref.Value, fd pref.FieldDescriptor) error {
// marshalSingular marshals the given non-repeated field value. This includes // marshalSingular marshals the given non-repeated field value. This includes
// all scalar types, enums, messages, and groups. // all scalar types, enums, messages, and groups.
func (e encoder) marshalSingular(val pref.Value, fd pref.FieldDescriptor) error { func (e encoder) marshalSingular(val protoreflect.Value, fd protoreflect.FieldDescriptor) error {
if !val.IsValid() { if !val.IsValid() {
e.WriteNull() e.WriteNull()
return nil return nil
} }
switch kind := fd.Kind(); kind { switch kind := fd.Kind(); kind {
case pref.BoolKind: case protoreflect.BoolKind:
e.WriteBool(val.Bool()) e.WriteBool(val.Bool())
case pref.StringKind: case protoreflect.StringKind:
if e.WriteString(val.String()) != nil { if e.WriteString(val.String()) != nil {
return errors.InvalidUTF8(string(fd.FullName())) return errors.InvalidUTF8(string(fd.FullName()))
} }
case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind: case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
e.WriteInt(val.Int()) e.WriteInt(val.Int())
case pref.Uint32Kind, pref.Fixed32Kind: case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
e.WriteUint(val.Uint()) e.WriteUint(val.Uint())
case pref.Int64Kind, pref.Sint64Kind, pref.Uint64Kind, case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Uint64Kind,
pref.Sfixed64Kind, pref.Fixed64Kind: protoreflect.Sfixed64Kind, protoreflect.Fixed64Kind:
// 64-bit integers are written out as JSON string. // 64-bit integers are written out as JSON string.
e.WriteString(val.String()) e.WriteString(val.String())
case pref.FloatKind: case protoreflect.FloatKind:
// Encoder.WriteFloat handles the special numbers NaN and infinites. // Encoder.WriteFloat handles the special numbers NaN and infinites.
e.WriteFloat(val.Float(), 32) e.WriteFloat(val.Float(), 32)
case pref.DoubleKind: case protoreflect.DoubleKind:
// Encoder.WriteFloat handles the special numbers NaN and infinites. // Encoder.WriteFloat handles the special numbers NaN and infinites.
e.WriteFloat(val.Float(), 64) e.WriteFloat(val.Float(), 64)
case pref.BytesKind: case protoreflect.BytesKind:
e.WriteString(base64.StdEncoding.EncodeToString(val.Bytes())) e.WriteString(base64.StdEncoding.EncodeToString(val.Bytes()))
case pref.EnumKind: case protoreflect.EnumKind:
if fd.Enum().FullName() == genid.NullValue_enum_fullname { if fd.Enum().FullName() == genid.NullValue_enum_fullname {
e.WriteNull() e.WriteNull()
} else { } else {
@ -300,7 +299,7 @@ func (e encoder) marshalSingular(val pref.Value, fd pref.FieldDescriptor) error
} }
} }
case pref.MessageKind, pref.GroupKind: case protoreflect.MessageKind, protoreflect.GroupKind:
if err := e.marshalMessage(val.Message(), ""); err != nil { if err := e.marshalMessage(val.Message(), ""); err != nil {
return err return err
} }
@ -312,7 +311,7 @@ func (e encoder) marshalSingular(val pref.Value, fd pref.FieldDescriptor) error
} }
// marshalList marshals the given protoreflect.List. // marshalList marshals the given protoreflect.List.
func (e encoder) marshalList(list pref.List, fd pref.FieldDescriptor) error { func (e encoder) marshalList(list protoreflect.List, fd protoreflect.FieldDescriptor) error {
e.StartArray() e.StartArray()
defer e.EndArray() defer e.EndArray()
@ -326,12 +325,12 @@ func (e encoder) marshalList(list pref.List, fd pref.FieldDescriptor) error {
} }
// marshalMap marshals given protoreflect.Map. // marshalMap marshals given protoreflect.Map.
func (e encoder) marshalMap(mmap pref.Map, fd pref.FieldDescriptor) error { func (e encoder) marshalMap(mmap protoreflect.Map, fd protoreflect.FieldDescriptor) error {
e.StartObject() e.StartObject()
defer e.EndObject() defer e.EndObject()
var err error var err error
order.RangeEntries(mmap, order.GenericKeyOrder, func(k pref.MapKey, v pref.Value) bool { order.RangeEntries(mmap, order.GenericKeyOrder, func(k protoreflect.MapKey, v protoreflect.Value) bool {
if err = e.WriteName(k.String()); err != nil { if err = e.WriteName(k.String()); err != nil {
return false return false
} }

View File

@ -17,14 +17,14 @@ import (
"google.golang.org/protobuf/internal/genid" "google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/internal/strs" "google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/proto" "google.golang.org/protobuf/proto"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
type marshalFunc func(encoder, pref.Message) error type marshalFunc func(encoder, protoreflect.Message) error
// wellKnownTypeMarshaler returns a marshal function if the message type // wellKnownTypeMarshaler returns a marshal function if the message type
// has specialized serialization behavior. It returns nil otherwise. // has specialized serialization behavior. It returns nil otherwise.
func wellKnownTypeMarshaler(name pref.FullName) marshalFunc { func wellKnownTypeMarshaler(name protoreflect.FullName) marshalFunc {
if name.Parent() == genid.GoogleProtobuf_package { if name.Parent() == genid.GoogleProtobuf_package {
switch name.Name() { switch name.Name() {
case genid.Any_message_name: case genid.Any_message_name:
@ -58,11 +58,11 @@ func wellKnownTypeMarshaler(name pref.FullName) marshalFunc {
return nil return nil
} }
type unmarshalFunc func(decoder, pref.Message) error type unmarshalFunc func(decoder, protoreflect.Message) error
// wellKnownTypeUnmarshaler returns a unmarshal function if the message type // wellKnownTypeUnmarshaler returns a unmarshal function if the message type
// has specialized serialization behavior. It returns nil otherwise. // has specialized serialization behavior. It returns nil otherwise.
func wellKnownTypeUnmarshaler(name pref.FullName) unmarshalFunc { func wellKnownTypeUnmarshaler(name protoreflect.FullName) unmarshalFunc {
if name.Parent() == genid.GoogleProtobuf_package { if name.Parent() == genid.GoogleProtobuf_package {
switch name.Name() { switch name.Name() {
case genid.Any_message_name: case genid.Any_message_name:
@ -102,7 +102,7 @@ func wellKnownTypeUnmarshaler(name pref.FullName) unmarshalFunc {
// custom JSON representation, that representation will be embedded adding a // custom JSON representation, that representation will be embedded adding a
// field `value` which holds the custom JSON in addition to the `@type` field. // field `value` which holds the custom JSON in addition to the `@type` field.
func (e encoder) marshalAny(m pref.Message) error { func (e encoder) marshalAny(m protoreflect.Message) error {
fds := m.Descriptor().Fields() fds := m.Descriptor().Fields()
fdType := fds.ByNumber(genid.Any_TypeUrl_field_number) fdType := fds.ByNumber(genid.Any_TypeUrl_field_number)
fdValue := fds.ByNumber(genid.Any_Value_field_number) fdValue := fds.ByNumber(genid.Any_Value_field_number)
@ -163,7 +163,7 @@ func (e encoder) marshalAny(m pref.Message) error {
return nil return nil
} }
func (d decoder) unmarshalAny(m pref.Message) error { func (d decoder) unmarshalAny(m protoreflect.Message) error {
// Peek to check for json.ObjectOpen to avoid advancing a read. // Peek to check for json.ObjectOpen to avoid advancing a read.
start, err := d.Peek() start, err := d.Peek()
if err != nil { if err != nil {
@ -233,8 +233,8 @@ func (d decoder) unmarshalAny(m pref.Message) error {
fdType := fds.ByNumber(genid.Any_TypeUrl_field_number) fdType := fds.ByNumber(genid.Any_TypeUrl_field_number)
fdValue := fds.ByNumber(genid.Any_Value_field_number) fdValue := fds.ByNumber(genid.Any_Value_field_number)
m.Set(fdType, pref.ValueOfString(typeURL)) m.Set(fdType, protoreflect.ValueOfString(typeURL))
m.Set(fdValue, pref.ValueOfBytes(b)) m.Set(fdValue, protoreflect.ValueOfBytes(b))
return nil return nil
} }
@ -354,7 +354,7 @@ func (d decoder) skipJSONValue() error {
// unmarshalAnyValue unmarshals the given custom-type message from the JSON // unmarshalAnyValue unmarshals the given custom-type message from the JSON
// object's "value" field. // object's "value" field.
func (d decoder) unmarshalAnyValue(unmarshal unmarshalFunc, m pref.Message) error { func (d decoder) unmarshalAnyValue(unmarshal unmarshalFunc, m protoreflect.Message) error {
// Skip ObjectOpen, and start reading the fields. // Skip ObjectOpen, and start reading the fields.
d.Read() d.Read()
@ -402,13 +402,13 @@ func (d decoder) unmarshalAnyValue(unmarshal unmarshalFunc, m pref.Message) erro
// Wrapper types are encoded as JSON primitives like string, number or boolean. // Wrapper types are encoded as JSON primitives like string, number or boolean.
func (e encoder) marshalWrapperType(m pref.Message) error { func (e encoder) marshalWrapperType(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.WrapperValue_Value_field_number) fd := m.Descriptor().Fields().ByNumber(genid.WrapperValue_Value_field_number)
val := m.Get(fd) val := m.Get(fd)
return e.marshalSingular(val, fd) return e.marshalSingular(val, fd)
} }
func (d decoder) unmarshalWrapperType(m pref.Message) error { func (d decoder) unmarshalWrapperType(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.WrapperValue_Value_field_number) fd := m.Descriptor().Fields().ByNumber(genid.WrapperValue_Value_field_number)
val, err := d.unmarshalScalar(fd) val, err := d.unmarshalScalar(fd)
if err != nil { if err != nil {
@ -420,13 +420,13 @@ func (d decoder) unmarshalWrapperType(m pref.Message) error {
// The JSON representation for Empty is an empty JSON object. // The JSON representation for Empty is an empty JSON object.
func (e encoder) marshalEmpty(pref.Message) error { func (e encoder) marshalEmpty(protoreflect.Message) error {
e.StartObject() e.StartObject()
e.EndObject() e.EndObject()
return nil return nil
} }
func (d decoder) unmarshalEmpty(pref.Message) error { func (d decoder) unmarshalEmpty(protoreflect.Message) error {
tok, err := d.Read() tok, err := d.Read()
if err != nil { if err != nil {
return err return err
@ -462,12 +462,12 @@ func (d decoder) unmarshalEmpty(pref.Message) error {
// The JSON representation for Struct is a JSON object that contains the encoded // The JSON representation for Struct is a JSON object that contains the encoded
// Struct.fields map and follows the serialization rules for a map. // Struct.fields map and follows the serialization rules for a map.
func (e encoder) marshalStruct(m pref.Message) error { func (e encoder) marshalStruct(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.Struct_Fields_field_number) fd := m.Descriptor().Fields().ByNumber(genid.Struct_Fields_field_number)
return e.marshalMap(m.Get(fd).Map(), fd) return e.marshalMap(m.Get(fd).Map(), fd)
} }
func (d decoder) unmarshalStruct(m pref.Message) error { func (d decoder) unmarshalStruct(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.Struct_Fields_field_number) fd := m.Descriptor().Fields().ByNumber(genid.Struct_Fields_field_number)
return d.unmarshalMap(m.Mutable(fd).Map(), fd) return d.unmarshalMap(m.Mutable(fd).Map(), fd)
} }
@ -476,12 +476,12 @@ func (d decoder) unmarshalStruct(m pref.Message) error {
// ListValue.values repeated field and follows the serialization rules for a // ListValue.values repeated field and follows the serialization rules for a
// repeated field. // repeated field.
func (e encoder) marshalListValue(m pref.Message) error { func (e encoder) marshalListValue(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.ListValue_Values_field_number) fd := m.Descriptor().Fields().ByNumber(genid.ListValue_Values_field_number)
return e.marshalList(m.Get(fd).List(), fd) return e.marshalList(m.Get(fd).List(), fd)
} }
func (d decoder) unmarshalListValue(m pref.Message) error { func (d decoder) unmarshalListValue(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.ListValue_Values_field_number) fd := m.Descriptor().Fields().ByNumber(genid.ListValue_Values_field_number)
return d.unmarshalList(m.Mutable(fd).List(), fd) return d.unmarshalList(m.Mutable(fd).List(), fd)
} }
@ -490,7 +490,7 @@ func (d decoder) unmarshalListValue(m pref.Message) error {
// set. Each of the field in the oneof has its own custom serialization rule. A // set. Each of the field in the oneof has its own custom serialization rule. A
// Value message needs to be a oneof field set, else it is an error. // Value message needs to be a oneof field set, else it is an error.
func (e encoder) marshalKnownValue(m pref.Message) error { func (e encoder) marshalKnownValue(m protoreflect.Message) error {
od := m.Descriptor().Oneofs().ByName(genid.Value_Kind_oneof_name) od := m.Descriptor().Oneofs().ByName(genid.Value_Kind_oneof_name)
fd := m.WhichOneof(od) fd := m.WhichOneof(od)
if fd == nil { if fd == nil {
@ -504,19 +504,19 @@ func (e encoder) marshalKnownValue(m pref.Message) error {
return e.marshalSingular(m.Get(fd), fd) return e.marshalSingular(m.Get(fd), fd)
} }
func (d decoder) unmarshalKnownValue(m pref.Message) error { func (d decoder) unmarshalKnownValue(m protoreflect.Message) error {
tok, err := d.Peek() tok, err := d.Peek()
if err != nil { if err != nil {
return err return err
} }
var fd pref.FieldDescriptor var fd protoreflect.FieldDescriptor
var val pref.Value var val protoreflect.Value
switch tok.Kind() { switch tok.Kind() {
case json.Null: case json.Null:
d.Read() d.Read()
fd = m.Descriptor().Fields().ByNumber(genid.Value_NullValue_field_number) fd = m.Descriptor().Fields().ByNumber(genid.Value_NullValue_field_number)
val = pref.ValueOfEnum(0) val = protoreflect.ValueOfEnum(0)
case json.Bool: case json.Bool:
tok, err := d.Read() tok, err := d.Read()
@ -524,7 +524,7 @@ func (d decoder) unmarshalKnownValue(m pref.Message) error {
return err return err
} }
fd = m.Descriptor().Fields().ByNumber(genid.Value_BoolValue_field_number) fd = m.Descriptor().Fields().ByNumber(genid.Value_BoolValue_field_number)
val = pref.ValueOfBool(tok.Bool()) val = protoreflect.ValueOfBool(tok.Bool())
case json.Number: case json.Number:
tok, err := d.Read() tok, err := d.Read()
@ -550,7 +550,7 @@ func (d decoder) unmarshalKnownValue(m pref.Message) error {
return err return err
} }
fd = m.Descriptor().Fields().ByNumber(genid.Value_StringValue_field_number) fd = m.Descriptor().Fields().ByNumber(genid.Value_StringValue_field_number)
val = pref.ValueOfString(tok.ParsedString()) val = protoreflect.ValueOfString(tok.ParsedString())
case json.ObjectOpen: case json.ObjectOpen:
fd = m.Descriptor().Fields().ByNumber(genid.Value_StructValue_field_number) fd = m.Descriptor().Fields().ByNumber(genid.Value_StructValue_field_number)
@ -591,7 +591,7 @@ const (
maxSecondsInDuration = 315576000000 maxSecondsInDuration = 315576000000
) )
func (e encoder) marshalDuration(m pref.Message) error { func (e encoder) marshalDuration(m protoreflect.Message) error {
fds := m.Descriptor().Fields() fds := m.Descriptor().Fields()
fdSeconds := fds.ByNumber(genid.Duration_Seconds_field_number) fdSeconds := fds.ByNumber(genid.Duration_Seconds_field_number)
fdNanos := fds.ByNumber(genid.Duration_Nanos_field_number) fdNanos := fds.ByNumber(genid.Duration_Nanos_field_number)
@ -623,7 +623,7 @@ func (e encoder) marshalDuration(m pref.Message) error {
return nil return nil
} }
func (d decoder) unmarshalDuration(m pref.Message) error { func (d decoder) unmarshalDuration(m protoreflect.Message) error {
tok, err := d.Read() tok, err := d.Read()
if err != nil { if err != nil {
return err return err
@ -646,8 +646,8 @@ func (d decoder) unmarshalDuration(m pref.Message) error {
fdSeconds := fds.ByNumber(genid.Duration_Seconds_field_number) fdSeconds := fds.ByNumber(genid.Duration_Seconds_field_number)
fdNanos := fds.ByNumber(genid.Duration_Nanos_field_number) fdNanos := fds.ByNumber(genid.Duration_Nanos_field_number)
m.Set(fdSeconds, pref.ValueOfInt64(secs)) m.Set(fdSeconds, protoreflect.ValueOfInt64(secs))
m.Set(fdNanos, pref.ValueOfInt32(nanos)) m.Set(fdNanos, protoreflect.ValueOfInt32(nanos))
return nil return nil
} }
@ -779,7 +779,7 @@ const (
minTimestampSeconds = -62135596800 minTimestampSeconds = -62135596800
) )
func (e encoder) marshalTimestamp(m pref.Message) error { func (e encoder) marshalTimestamp(m protoreflect.Message) error {
fds := m.Descriptor().Fields() fds := m.Descriptor().Fields()
fdSeconds := fds.ByNumber(genid.Timestamp_Seconds_field_number) fdSeconds := fds.ByNumber(genid.Timestamp_Seconds_field_number)
fdNanos := fds.ByNumber(genid.Timestamp_Nanos_field_number) fdNanos := fds.ByNumber(genid.Timestamp_Nanos_field_number)
@ -805,7 +805,7 @@ func (e encoder) marshalTimestamp(m pref.Message) error {
return nil return nil
} }
func (d decoder) unmarshalTimestamp(m pref.Message) error { func (d decoder) unmarshalTimestamp(m protoreflect.Message) error {
tok, err := d.Read() tok, err := d.Read()
if err != nil { if err != nil {
return err return err
@ -829,8 +829,8 @@ func (d decoder) unmarshalTimestamp(m pref.Message) error {
fdSeconds := fds.ByNumber(genid.Timestamp_Seconds_field_number) fdSeconds := fds.ByNumber(genid.Timestamp_Seconds_field_number)
fdNanos := fds.ByNumber(genid.Timestamp_Nanos_field_number) fdNanos := fds.ByNumber(genid.Timestamp_Nanos_field_number)
m.Set(fdSeconds, pref.ValueOfInt64(secs)) m.Set(fdSeconds, protoreflect.ValueOfInt64(secs))
m.Set(fdNanos, pref.ValueOfInt32(int32(t.Nanosecond()))) m.Set(fdNanos, protoreflect.ValueOfInt32(int32(t.Nanosecond())))
return nil return nil
} }
@ -839,14 +839,14 @@ func (d decoder) unmarshalTimestamp(m pref.Message) error {
// lower-camel naming conventions. Encoding should fail if the path name would // lower-camel naming conventions. Encoding should fail if the path name would
// end up differently after a round-trip. // end up differently after a round-trip.
func (e encoder) marshalFieldMask(m pref.Message) error { func (e encoder) marshalFieldMask(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.FieldMask_Paths_field_number) fd := m.Descriptor().Fields().ByNumber(genid.FieldMask_Paths_field_number)
list := m.Get(fd).List() list := m.Get(fd).List()
paths := make([]string, 0, list.Len()) paths := make([]string, 0, list.Len())
for i := 0; i < list.Len(); i++ { for i := 0; i < list.Len(); i++ {
s := list.Get(i).String() s := list.Get(i).String()
if !pref.FullName(s).IsValid() { if !protoreflect.FullName(s).IsValid() {
return errors.New("%s contains invalid path: %q", genid.FieldMask_Paths_field_fullname, s) return errors.New("%s contains invalid path: %q", genid.FieldMask_Paths_field_fullname, s)
} }
// Return error if conversion to camelCase is not reversible. // Return error if conversion to camelCase is not reversible.
@ -861,7 +861,7 @@ func (e encoder) marshalFieldMask(m pref.Message) error {
return nil return nil
} }
func (d decoder) unmarshalFieldMask(m pref.Message) error { func (d decoder) unmarshalFieldMask(m protoreflect.Message) error {
tok, err := d.Read() tok, err := d.Read()
if err != nil { if err != nil {
return err return err
@ -880,10 +880,10 @@ func (d decoder) unmarshalFieldMask(m pref.Message) error {
for _, s0 := range paths { for _, s0 := range paths {
s := strs.JSONSnakeCase(s0) s := strs.JSONSnakeCase(s0)
if strings.Contains(s0, "_") || !pref.FullName(s).IsValid() { if strings.Contains(s0, "_") || !protoreflect.FullName(s).IsValid() {
return d.newError(tok.Pos(), "%v contains invalid path: %q", genid.FieldMask_Paths_field_fullname, s0) return d.newError(tok.Pos(), "%v contains invalid path: %q", genid.FieldMask_Paths_field_fullname, s0)
} }
list.Append(pref.ValueOfString(s)) list.Append(protoreflect.ValueOfString(s))
} }
return nil return nil
} }

View File

@ -17,7 +17,7 @@ import (
"google.golang.org/protobuf/internal/set" "google.golang.org/protobuf/internal/set"
"google.golang.org/protobuf/internal/strs" "google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/proto" "google.golang.org/protobuf/proto"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry" "google.golang.org/protobuf/reflect/protoregistry"
) )
@ -103,7 +103,7 @@ func (d decoder) syntaxError(pos int, f string, x ...interface{}) error {
} }
// unmarshalMessage unmarshals into the given protoreflect.Message. // unmarshalMessage unmarshals into the given protoreflect.Message.
func (d decoder) unmarshalMessage(m pref.Message, checkDelims bool) error { func (d decoder) unmarshalMessage(m protoreflect.Message, checkDelims bool) error {
messageDesc := m.Descriptor() messageDesc := m.Descriptor()
if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) { if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
return errors.New("no support for proto1 MessageSets") return errors.New("no support for proto1 MessageSets")
@ -150,24 +150,24 @@ func (d decoder) unmarshalMessage(m pref.Message, checkDelims bool) error {
} }
// Resolve the field descriptor. // Resolve the field descriptor.
var name pref.Name var name protoreflect.Name
var fd pref.FieldDescriptor var fd protoreflect.FieldDescriptor
var xt pref.ExtensionType var xt protoreflect.ExtensionType
var xtErr error var xtErr error
var isFieldNumberName bool var isFieldNumberName bool
switch tok.NameKind() { switch tok.NameKind() {
case text.IdentName: case text.IdentName:
name = pref.Name(tok.IdentName()) name = protoreflect.Name(tok.IdentName())
fd = fieldDescs.ByTextName(string(name)) fd = fieldDescs.ByTextName(string(name))
case text.TypeName: case text.TypeName:
// Handle extensions only. This code path is not for Any. // Handle extensions only. This code path is not for Any.
xt, xtErr = d.opts.Resolver.FindExtensionByName(pref.FullName(tok.TypeName())) xt, xtErr = d.opts.Resolver.FindExtensionByName(protoreflect.FullName(tok.TypeName()))
case text.FieldNumber: case text.FieldNumber:
isFieldNumberName = true isFieldNumberName = true
num := pref.FieldNumber(tok.FieldNumber()) num := protoreflect.FieldNumber(tok.FieldNumber())
if !num.IsValid() { if !num.IsValid() {
return d.newError(tok.Pos(), "invalid field number: %d", num) return d.newError(tok.Pos(), "invalid field number: %d", num)
} }
@ -215,7 +215,7 @@ func (d decoder) unmarshalMessage(m pref.Message, checkDelims bool) error {
switch { switch {
case fd.IsList(): case fd.IsList():
kind := fd.Kind() kind := fd.Kind()
if kind != pref.MessageKind && kind != pref.GroupKind && !tok.HasSeparator() { if kind != protoreflect.MessageKind && kind != protoreflect.GroupKind && !tok.HasSeparator() {
return d.syntaxError(tok.Pos(), "missing field separator :") return d.syntaxError(tok.Pos(), "missing field separator :")
} }
@ -232,7 +232,7 @@ func (d decoder) unmarshalMessage(m pref.Message, checkDelims bool) error {
default: default:
kind := fd.Kind() kind := fd.Kind()
if kind != pref.MessageKind && kind != pref.GroupKind && !tok.HasSeparator() { if kind != protoreflect.MessageKind && kind != protoreflect.GroupKind && !tok.HasSeparator() {
return d.syntaxError(tok.Pos(), "missing field separator :") return d.syntaxError(tok.Pos(), "missing field separator :")
} }
@ -262,11 +262,11 @@ func (d decoder) unmarshalMessage(m pref.Message, checkDelims bool) error {
// unmarshalSingular unmarshals a non-repeated field value specified by the // unmarshalSingular unmarshals a non-repeated field value specified by the
// given FieldDescriptor. // given FieldDescriptor.
func (d decoder) unmarshalSingular(fd pref.FieldDescriptor, m pref.Message) error { func (d decoder) unmarshalSingular(fd protoreflect.FieldDescriptor, m protoreflect.Message) error {
var val pref.Value var val protoreflect.Value
var err error var err error
switch fd.Kind() { switch fd.Kind() {
case pref.MessageKind, pref.GroupKind: case protoreflect.MessageKind, protoreflect.GroupKind:
val = m.NewField(fd) val = m.NewField(fd)
err = d.unmarshalMessage(val.Message(), true) err = d.unmarshalMessage(val.Message(), true)
default: default:
@ -280,94 +280,94 @@ func (d decoder) unmarshalSingular(fd pref.FieldDescriptor, m pref.Message) erro
// unmarshalScalar unmarshals a scalar/enum protoreflect.Value specified by the // unmarshalScalar unmarshals a scalar/enum protoreflect.Value specified by the
// given FieldDescriptor. // given FieldDescriptor.
func (d decoder) unmarshalScalar(fd pref.FieldDescriptor) (pref.Value, error) { func (d decoder) unmarshalScalar(fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
tok, err := d.Read() tok, err := d.Read()
if err != nil { if err != nil {
return pref.Value{}, err return protoreflect.Value{}, err
} }
if tok.Kind() != text.Scalar { if tok.Kind() != text.Scalar {
return pref.Value{}, d.unexpectedTokenError(tok) return protoreflect.Value{}, d.unexpectedTokenError(tok)
} }
kind := fd.Kind() kind := fd.Kind()
switch kind { switch kind {
case pref.BoolKind: case protoreflect.BoolKind:
if b, ok := tok.Bool(); ok { if b, ok := tok.Bool(); ok {
return pref.ValueOfBool(b), nil return protoreflect.ValueOfBool(b), nil
} }
case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind: case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
if n, ok := tok.Int32(); ok { if n, ok := tok.Int32(); ok {
return pref.ValueOfInt32(n), nil return protoreflect.ValueOfInt32(n), nil
} }
case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind: case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
if n, ok := tok.Int64(); ok { if n, ok := tok.Int64(); ok {
return pref.ValueOfInt64(n), nil return protoreflect.ValueOfInt64(n), nil
} }
case pref.Uint32Kind, pref.Fixed32Kind: case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
if n, ok := tok.Uint32(); ok { if n, ok := tok.Uint32(); ok {
return pref.ValueOfUint32(n), nil return protoreflect.ValueOfUint32(n), nil
} }
case pref.Uint64Kind, pref.Fixed64Kind: case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
if n, ok := tok.Uint64(); ok { if n, ok := tok.Uint64(); ok {
return pref.ValueOfUint64(n), nil return protoreflect.ValueOfUint64(n), nil
} }
case pref.FloatKind: case protoreflect.FloatKind:
if n, ok := tok.Float32(); ok { if n, ok := tok.Float32(); ok {
return pref.ValueOfFloat32(n), nil return protoreflect.ValueOfFloat32(n), nil
} }
case pref.DoubleKind: case protoreflect.DoubleKind:
if n, ok := tok.Float64(); ok { if n, ok := tok.Float64(); ok {
return pref.ValueOfFloat64(n), nil return protoreflect.ValueOfFloat64(n), nil
} }
case pref.StringKind: case protoreflect.StringKind:
if s, ok := tok.String(); ok { if s, ok := tok.String(); ok {
if strs.EnforceUTF8(fd) && !utf8.ValidString(s) { if strs.EnforceUTF8(fd) && !utf8.ValidString(s) {
return pref.Value{}, d.newError(tok.Pos(), "contains invalid UTF-8") return protoreflect.Value{}, d.newError(tok.Pos(), "contains invalid UTF-8")
} }
return pref.ValueOfString(s), nil return protoreflect.ValueOfString(s), nil
} }
case pref.BytesKind: case protoreflect.BytesKind:
if b, ok := tok.String(); ok { if b, ok := tok.String(); ok {
return pref.ValueOfBytes([]byte(b)), nil return protoreflect.ValueOfBytes([]byte(b)), nil
} }
case pref.EnumKind: case protoreflect.EnumKind:
if lit, ok := tok.Enum(); ok { if lit, ok := tok.Enum(); ok {
// Lookup EnumNumber based on name. // Lookup EnumNumber based on name.
if enumVal := fd.Enum().Values().ByName(pref.Name(lit)); enumVal != nil { if enumVal := fd.Enum().Values().ByName(protoreflect.Name(lit)); enumVal != nil {
return pref.ValueOfEnum(enumVal.Number()), nil return protoreflect.ValueOfEnum(enumVal.Number()), nil
} }
} }
if num, ok := tok.Int32(); ok { if num, ok := tok.Int32(); ok {
return pref.ValueOfEnum(pref.EnumNumber(num)), nil return protoreflect.ValueOfEnum(protoreflect.EnumNumber(num)), nil
} }
default: default:
panic(fmt.Sprintf("invalid scalar kind %v", kind)) panic(fmt.Sprintf("invalid scalar kind %v", kind))
} }
return pref.Value{}, d.newError(tok.Pos(), "invalid value for %v type: %v", kind, tok.RawString()) return protoreflect.Value{}, d.newError(tok.Pos(), "invalid value for %v type: %v", kind, tok.RawString())
} }
// unmarshalList unmarshals into given protoreflect.List. A list value can // unmarshalList unmarshals into given protoreflect.List. A list value can
// either be in [] syntax or simply just a single scalar/message value. // either be in [] syntax or simply just a single scalar/message value.
func (d decoder) unmarshalList(fd pref.FieldDescriptor, list pref.List) error { func (d decoder) unmarshalList(fd protoreflect.FieldDescriptor, list protoreflect.List) error {
tok, err := d.Peek() tok, err := d.Peek()
if err != nil { if err != nil {
return err return err
} }
switch fd.Kind() { switch fd.Kind() {
case pref.MessageKind, pref.GroupKind: case protoreflect.MessageKind, protoreflect.GroupKind:
switch tok.Kind() { switch tok.Kind() {
case text.ListOpen: case text.ListOpen:
d.Read() d.Read()
@ -441,22 +441,22 @@ func (d decoder) unmarshalList(fd pref.FieldDescriptor, list pref.List) error {
// unmarshalMap unmarshals into given protoreflect.Map. A map value is a // unmarshalMap unmarshals into given protoreflect.Map. A map value is a
// textproto message containing {key: <kvalue>, value: <mvalue>}. // textproto message containing {key: <kvalue>, value: <mvalue>}.
func (d decoder) unmarshalMap(fd pref.FieldDescriptor, mmap pref.Map) error { func (d decoder) unmarshalMap(fd protoreflect.FieldDescriptor, mmap protoreflect.Map) error {
// Determine ahead whether map entry is a scalar type or a message type in // Determine ahead whether map entry is a scalar type or a message type in
// order to call the appropriate unmarshalMapValue func inside // order to call the appropriate unmarshalMapValue func inside
// unmarshalMapEntry. // unmarshalMapEntry.
var unmarshalMapValue func() (pref.Value, error) var unmarshalMapValue func() (protoreflect.Value, error)
switch fd.MapValue().Kind() { switch fd.MapValue().Kind() {
case pref.MessageKind, pref.GroupKind: case protoreflect.MessageKind, protoreflect.GroupKind:
unmarshalMapValue = func() (pref.Value, error) { unmarshalMapValue = func() (protoreflect.Value, error) {
pval := mmap.NewValue() pval := mmap.NewValue()
if err := d.unmarshalMessage(pval.Message(), true); err != nil { if err := d.unmarshalMessage(pval.Message(), true); err != nil {
return pref.Value{}, err return protoreflect.Value{}, err
} }
return pval, nil return pval, nil
} }
default: default:
unmarshalMapValue = func() (pref.Value, error) { unmarshalMapValue = func() (protoreflect.Value, error) {
return d.unmarshalScalar(fd.MapValue()) return d.unmarshalScalar(fd.MapValue())
} }
} }
@ -494,9 +494,9 @@ func (d decoder) unmarshalMap(fd pref.FieldDescriptor, mmap pref.Map) error {
// unmarshalMap unmarshals into given protoreflect.Map. A map value is a // unmarshalMap unmarshals into given protoreflect.Map. A map value is a
// textproto message containing {key: <kvalue>, value: <mvalue>}. // textproto message containing {key: <kvalue>, value: <mvalue>}.
func (d decoder) unmarshalMapEntry(fd pref.FieldDescriptor, mmap pref.Map, unmarshalMapValue func() (pref.Value, error)) error { func (d decoder) unmarshalMapEntry(fd protoreflect.FieldDescriptor, mmap protoreflect.Map, unmarshalMapValue func() (protoreflect.Value, error)) error {
var key pref.MapKey var key protoreflect.MapKey
var pval pref.Value var pval protoreflect.Value
Loop: Loop:
for { for {
// Read field name. // Read field name.
@ -520,7 +520,7 @@ Loop:
return d.unexpectedTokenError(tok) return d.unexpectedTokenError(tok)
} }
switch name := pref.Name(tok.IdentName()); name { switch name := protoreflect.Name(tok.IdentName()); name {
case genid.MapEntry_Key_field_name: case genid.MapEntry_Key_field_name:
if !tok.HasSeparator() { if !tok.HasSeparator() {
return d.syntaxError(tok.Pos(), "missing field separator :") return d.syntaxError(tok.Pos(), "missing field separator :")
@ -535,7 +535,7 @@ Loop:
key = val.MapKey() key = val.MapKey()
case genid.MapEntry_Value_field_name: case genid.MapEntry_Value_field_name:
if kind := fd.MapValue().Kind(); (kind != pref.MessageKind) && (kind != pref.GroupKind) { if kind := fd.MapValue().Kind(); (kind != protoreflect.MessageKind) && (kind != protoreflect.GroupKind) {
if !tok.HasSeparator() { if !tok.HasSeparator() {
return d.syntaxError(tok.Pos(), "missing field separator :") return d.syntaxError(tok.Pos(), "missing field separator :")
} }
@ -561,7 +561,7 @@ Loop:
} }
if !pval.IsValid() { if !pval.IsValid() {
switch fd.MapValue().Kind() { switch fd.MapValue().Kind() {
case pref.MessageKind, pref.GroupKind: case protoreflect.MessageKind, protoreflect.GroupKind:
// If value field is not set for message/group types, construct an // If value field is not set for message/group types, construct an
// empty one as default. // empty one as default.
pval = mmap.NewValue() pval = mmap.NewValue()
@ -575,7 +575,7 @@ Loop:
// unmarshalAny unmarshals an Any textproto. It can either be in expanded form // unmarshalAny unmarshals an Any textproto. It can either be in expanded form
// or non-expanded form. // or non-expanded form.
func (d decoder) unmarshalAny(m pref.Message, checkDelims bool) error { func (d decoder) unmarshalAny(m protoreflect.Message, checkDelims bool) error {
var typeURL string var typeURL string
var bValue []byte var bValue []byte
var seenTypeUrl bool var seenTypeUrl bool
@ -619,7 +619,7 @@ Loop:
return d.syntaxError(tok.Pos(), "missing field separator :") return d.syntaxError(tok.Pos(), "missing field separator :")
} }
switch name := pref.Name(tok.IdentName()); name { switch name := protoreflect.Name(tok.IdentName()); name {
case genid.Any_TypeUrl_field_name: case genid.Any_TypeUrl_field_name:
if seenTypeUrl { if seenTypeUrl {
return d.newError(tok.Pos(), "duplicate %v field", genid.Any_TypeUrl_field_fullname) return d.newError(tok.Pos(), "duplicate %v field", genid.Any_TypeUrl_field_fullname)
@ -686,10 +686,10 @@ Loop:
fds := m.Descriptor().Fields() fds := m.Descriptor().Fields()
if len(typeURL) > 0 { if len(typeURL) > 0 {
m.Set(fds.ByNumber(genid.Any_TypeUrl_field_number), pref.ValueOfString(typeURL)) m.Set(fds.ByNumber(genid.Any_TypeUrl_field_number), protoreflect.ValueOfString(typeURL))
} }
if len(bValue) > 0 { if len(bValue) > 0 {
m.Set(fds.ByNumber(genid.Any_Value_field_number), pref.ValueOfBytes(bValue)) m.Set(fds.ByNumber(genid.Any_Value_field_number), protoreflect.ValueOfBytes(bValue))
} }
return nil return nil
} }

View File

@ -20,7 +20,6 @@ import (
"google.golang.org/protobuf/internal/strs" "google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/proto" "google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry" "google.golang.org/protobuf/reflect/protoregistry"
) )
@ -150,7 +149,7 @@ type encoder struct {
} }
// marshalMessage marshals the given protoreflect.Message. // marshalMessage marshals the given protoreflect.Message.
func (e encoder) marshalMessage(m pref.Message, inclDelims bool) error { func (e encoder) marshalMessage(m protoreflect.Message, inclDelims bool) error {
messageDesc := m.Descriptor() messageDesc := m.Descriptor()
if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) { if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
return errors.New("no support for proto1 MessageSets") return errors.New("no support for proto1 MessageSets")
@ -190,7 +189,7 @@ func (e encoder) marshalMessage(m pref.Message, inclDelims bool) error {
} }
// marshalField marshals the given field with protoreflect.Value. // marshalField marshals the given field with protoreflect.Value.
func (e encoder) marshalField(name string, val pref.Value, fd pref.FieldDescriptor) error { func (e encoder) marshalField(name string, val protoreflect.Value, fd protoreflect.FieldDescriptor) error {
switch { switch {
case fd.IsList(): case fd.IsList():
return e.marshalList(name, val.List(), fd) return e.marshalList(name, val.List(), fd)
@ -204,40 +203,40 @@ func (e encoder) marshalField(name string, val pref.Value, fd pref.FieldDescript
// marshalSingular marshals the given non-repeated field value. This includes // marshalSingular marshals the given non-repeated field value. This includes
// all scalar types, enums, messages, and groups. // all scalar types, enums, messages, and groups.
func (e encoder) marshalSingular(val pref.Value, fd pref.FieldDescriptor) error { func (e encoder) marshalSingular(val protoreflect.Value, fd protoreflect.FieldDescriptor) error {
kind := fd.Kind() kind := fd.Kind()
switch kind { switch kind {
case pref.BoolKind: case protoreflect.BoolKind:
e.WriteBool(val.Bool()) e.WriteBool(val.Bool())
case pref.StringKind: case protoreflect.StringKind:
s := val.String() s := val.String()
if !e.opts.allowInvalidUTF8 && strs.EnforceUTF8(fd) && !utf8.ValidString(s) { if !e.opts.allowInvalidUTF8 && strs.EnforceUTF8(fd) && !utf8.ValidString(s) {
return errors.InvalidUTF8(string(fd.FullName())) return errors.InvalidUTF8(string(fd.FullName()))
} }
e.WriteString(s) e.WriteString(s)
case pref.Int32Kind, pref.Int64Kind, case protoreflect.Int32Kind, protoreflect.Int64Kind,
pref.Sint32Kind, pref.Sint64Kind, protoreflect.Sint32Kind, protoreflect.Sint64Kind,
pref.Sfixed32Kind, pref.Sfixed64Kind: protoreflect.Sfixed32Kind, protoreflect.Sfixed64Kind:
e.WriteInt(val.Int()) e.WriteInt(val.Int())
case pref.Uint32Kind, pref.Uint64Kind, case protoreflect.Uint32Kind, protoreflect.Uint64Kind,
pref.Fixed32Kind, pref.Fixed64Kind: protoreflect.Fixed32Kind, protoreflect.Fixed64Kind:
e.WriteUint(val.Uint()) e.WriteUint(val.Uint())
case pref.FloatKind: case protoreflect.FloatKind:
// Encoder.WriteFloat handles the special numbers NaN and infinites. // Encoder.WriteFloat handles the special numbers NaN and infinites.
e.WriteFloat(val.Float(), 32) e.WriteFloat(val.Float(), 32)
case pref.DoubleKind: case protoreflect.DoubleKind:
// Encoder.WriteFloat handles the special numbers NaN and infinites. // Encoder.WriteFloat handles the special numbers NaN and infinites.
e.WriteFloat(val.Float(), 64) e.WriteFloat(val.Float(), 64)
case pref.BytesKind: case protoreflect.BytesKind:
e.WriteString(string(val.Bytes())) e.WriteString(string(val.Bytes()))
case pref.EnumKind: case protoreflect.EnumKind:
num := val.Enum() num := val.Enum()
if desc := fd.Enum().Values().ByNumber(num); desc != nil { if desc := fd.Enum().Values().ByNumber(num); desc != nil {
e.WriteLiteral(string(desc.Name())) e.WriteLiteral(string(desc.Name()))
@ -246,7 +245,7 @@ func (e encoder) marshalSingular(val pref.Value, fd pref.FieldDescriptor) error
e.WriteInt(int64(num)) e.WriteInt(int64(num))
} }
case pref.MessageKind, pref.GroupKind: case protoreflect.MessageKind, protoreflect.GroupKind:
return e.marshalMessage(val.Message(), true) return e.marshalMessage(val.Message(), true)
default: default:
@ -256,7 +255,7 @@ func (e encoder) marshalSingular(val pref.Value, fd pref.FieldDescriptor) error
} }
// marshalList marshals the given protoreflect.List as multiple name-value fields. // marshalList marshals the given protoreflect.List as multiple name-value fields.
func (e encoder) marshalList(name string, list pref.List, fd pref.FieldDescriptor) error { func (e encoder) marshalList(name string, list protoreflect.List, fd protoreflect.FieldDescriptor) error {
size := list.Len() size := list.Len()
for i := 0; i < size; i++ { for i := 0; i < size; i++ {
e.WriteName(name) e.WriteName(name)
@ -268,9 +267,9 @@ func (e encoder) marshalList(name string, list pref.List, fd pref.FieldDescripto
} }
// marshalMap marshals the given protoreflect.Map as multiple name-value fields. // marshalMap marshals the given protoreflect.Map as multiple name-value fields.
func (e encoder) marshalMap(name string, mmap pref.Map, fd pref.FieldDescriptor) error { func (e encoder) marshalMap(name string, mmap protoreflect.Map, fd protoreflect.FieldDescriptor) error {
var err error var err error
order.RangeEntries(mmap, order.GenericKeyOrder, func(key pref.MapKey, val pref.Value) bool { order.RangeEntries(mmap, order.GenericKeyOrder, func(key protoreflect.MapKey, val protoreflect.Value) bool {
e.WriteName(name) e.WriteName(name)
e.StartMessage() e.StartMessage()
defer e.EndMessage() defer e.EndMessage()
@ -334,7 +333,7 @@ func (e encoder) marshalUnknown(b []byte) {
// marshalAny marshals the given google.protobuf.Any message in expanded form. // marshalAny marshals the given google.protobuf.Any message in expanded form.
// It returns true if it was able to marshal, else false. // It returns true if it was able to marshal, else false.
func (e encoder) marshalAny(any pref.Message) bool { func (e encoder) marshalAny(any protoreflect.Message) bool {
// Construct the embedded message. // Construct the embedded message.
fds := any.Descriptor().Fields() fds := any.Descriptor().Fields()
fdType := fds.ByNumber(genid.Any_TypeUrl_field_number) fdType := fds.ByNumber(genid.Any_TypeUrl_field_number)

View File

@ -516,6 +516,7 @@ func EncodeTag(num Number, typ Type) uint64 {
} }
// DecodeZigZag decodes a zig-zag-encoded uint64 as an int64. // DecodeZigZag decodes a zig-zag-encoded uint64 as an int64.
//
// Input: {…, 5, 3, 1, 0, 2, 4, 6, …} // Input: {…, 5, 3, 1, 0, 2, 4, 6, …}
// Output: {…, -3, -2, -1, 0, +1, +2, +3, …} // Output: {…, -3, -2, -1, 0, +1, +2, +3, …}
func DecodeZigZag(x uint64) int64 { func DecodeZigZag(x uint64) int64 {
@ -523,6 +524,7 @@ func DecodeZigZag(x uint64) int64 {
} }
// EncodeZigZag encodes an int64 as a zig-zag-encoded uint64. // EncodeZigZag encodes an int64 as a zig-zag-encoded uint64.
//
// Input: {…, -3, -2, -1, 0, +1, +2, +3, …} // Input: {…, -3, -2, -1, 0, +1, +2, +3, …}
// Output: {…, 5, 3, 1, 0, 2, 4, 6, …} // Output: {…, 5, 3, 1, 0, 2, 4, 6, …}
func EncodeZigZag(x int64) uint64 { func EncodeZigZag(x int64) uint64 {
@ -530,6 +532,7 @@ func EncodeZigZag(x int64) uint64 {
} }
// DecodeBool decodes a uint64 as a bool. // DecodeBool decodes a uint64 as a bool.
//
// Input: { 0, 1, 2, …} // Input: { 0, 1, 2, …}
// Output: {false, true, true, …} // Output: {false, true, true, …}
func DecodeBool(x uint64) bool { func DecodeBool(x uint64) bool {
@ -537,6 +540,7 @@ func DecodeBool(x uint64) bool {
} }
// EncodeBool encodes a bool as a uint64. // EncodeBool encodes a bool as a uint64.
//
// Input: {false, true} // Input: {false, true}
// Output: { 0, 1} // Output: { 0, 1}
func EncodeBool(x bool) uint64 { func EncodeBool(x bool) uint64 {

View File

@ -14,7 +14,7 @@ import (
"google.golang.org/protobuf/internal/detrand" "google.golang.org/protobuf/internal/detrand"
"google.golang.org/protobuf/internal/pragma" "google.golang.org/protobuf/internal/pragma"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
type list interface { type list interface {
@ -30,17 +30,17 @@ func formatListOpt(vs list, isRoot, allowMulti bool) string {
if isRoot { if isRoot {
var name string var name string
switch vs.(type) { switch vs.(type) {
case pref.Names: case protoreflect.Names:
name = "Names" name = "Names"
case pref.FieldNumbers: case protoreflect.FieldNumbers:
name = "FieldNumbers" name = "FieldNumbers"
case pref.FieldRanges: case protoreflect.FieldRanges:
name = "FieldRanges" name = "FieldRanges"
case pref.EnumRanges: case protoreflect.EnumRanges:
name = "EnumRanges" name = "EnumRanges"
case pref.FileImports: case protoreflect.FileImports:
name = "FileImports" name = "FileImports"
case pref.Descriptor: case protoreflect.Descriptor:
name = reflect.ValueOf(vs).MethodByName("Get").Type().Out(0).Name() + "s" name = reflect.ValueOf(vs).MethodByName("Get").Type().Out(0).Name() + "s"
default: default:
name = reflect.ValueOf(vs).Elem().Type().Name() name = reflect.ValueOf(vs).Elem().Type().Name()
@ -50,17 +50,17 @@ func formatListOpt(vs list, isRoot, allowMulti bool) string {
var ss []string var ss []string
switch vs := vs.(type) { switch vs := vs.(type) {
case pref.Names: case protoreflect.Names:
for i := 0; i < vs.Len(); i++ { for i := 0; i < vs.Len(); i++ {
ss = append(ss, fmt.Sprint(vs.Get(i))) ss = append(ss, fmt.Sprint(vs.Get(i)))
} }
return start + joinStrings(ss, false) + end return start + joinStrings(ss, false) + end
case pref.FieldNumbers: case protoreflect.FieldNumbers:
for i := 0; i < vs.Len(); i++ { for i := 0; i < vs.Len(); i++ {
ss = append(ss, fmt.Sprint(vs.Get(i))) ss = append(ss, fmt.Sprint(vs.Get(i)))
} }
return start + joinStrings(ss, false) + end return start + joinStrings(ss, false) + end
case pref.FieldRanges: case protoreflect.FieldRanges:
for i := 0; i < vs.Len(); i++ { for i := 0; i < vs.Len(); i++ {
r := vs.Get(i) r := vs.Get(i)
if r[0]+1 == r[1] { if r[0]+1 == r[1] {
@ -70,7 +70,7 @@ func formatListOpt(vs list, isRoot, allowMulti bool) string {
} }
} }
return start + joinStrings(ss, false) + end return start + joinStrings(ss, false) + end
case pref.EnumRanges: case protoreflect.EnumRanges:
for i := 0; i < vs.Len(); i++ { for i := 0; i < vs.Len(); i++ {
r := vs.Get(i) r := vs.Get(i)
if r[0] == r[1] { if r[0] == r[1] {
@ -80,7 +80,7 @@ func formatListOpt(vs list, isRoot, allowMulti bool) string {
} }
} }
return start + joinStrings(ss, false) + end return start + joinStrings(ss, false) + end
case pref.FileImports: case protoreflect.FileImports:
for i := 0; i < vs.Len(); i++ { for i := 0; i < vs.Len(); i++ {
var rs records var rs records
rs.Append(reflect.ValueOf(vs.Get(i)), "Path", "Package", "IsPublic", "IsWeak") rs.Append(reflect.ValueOf(vs.Get(i)), "Path", "Package", "IsPublic", "IsWeak")
@ -88,11 +88,11 @@ func formatListOpt(vs list, isRoot, allowMulti bool) string {
} }
return start + joinStrings(ss, allowMulti) + end return start + joinStrings(ss, allowMulti) + end
default: default:
_, isEnumValue := vs.(pref.EnumValueDescriptors) _, isEnumValue := vs.(protoreflect.EnumValueDescriptors)
for i := 0; i < vs.Len(); i++ { for i := 0; i < vs.Len(); i++ {
m := reflect.ValueOf(vs).MethodByName("Get") m := reflect.ValueOf(vs).MethodByName("Get")
v := m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface() v := m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface()
ss = append(ss, formatDescOpt(v.(pref.Descriptor), false, allowMulti && !isEnumValue)) ss = append(ss, formatDescOpt(v.(protoreflect.Descriptor), false, allowMulti && !isEnumValue))
} }
return start + joinStrings(ss, allowMulti && isEnumValue) + end return start + joinStrings(ss, allowMulti && isEnumValue) + end
} }
@ -106,20 +106,20 @@ func formatListOpt(vs list, isRoot, allowMulti bool) string {
// //
// Using a list allows us to print the accessors in a sensible order. // Using a list allows us to print the accessors in a sensible order.
var descriptorAccessors = map[reflect.Type][]string{ var descriptorAccessors = map[reflect.Type][]string{
reflect.TypeOf((*pref.FileDescriptor)(nil)).Elem(): {"Path", "Package", "Imports", "Messages", "Enums", "Extensions", "Services"}, reflect.TypeOf((*protoreflect.FileDescriptor)(nil)).Elem(): {"Path", "Package", "Imports", "Messages", "Enums", "Extensions", "Services"},
reflect.TypeOf((*pref.MessageDescriptor)(nil)).Elem(): {"IsMapEntry", "Fields", "Oneofs", "ReservedNames", "ReservedRanges", "RequiredNumbers", "ExtensionRanges", "Messages", "Enums", "Extensions"}, reflect.TypeOf((*protoreflect.MessageDescriptor)(nil)).Elem(): {"IsMapEntry", "Fields", "Oneofs", "ReservedNames", "ReservedRanges", "RequiredNumbers", "ExtensionRanges", "Messages", "Enums", "Extensions"},
reflect.TypeOf((*pref.FieldDescriptor)(nil)).Elem(): {"Number", "Cardinality", "Kind", "HasJSONName", "JSONName", "HasPresence", "IsExtension", "IsPacked", "IsWeak", "IsList", "IsMap", "MapKey", "MapValue", "HasDefault", "Default", "ContainingOneof", "ContainingMessage", "Message", "Enum"}, reflect.TypeOf((*protoreflect.FieldDescriptor)(nil)).Elem(): {"Number", "Cardinality", "Kind", "HasJSONName", "JSONName", "HasPresence", "IsExtension", "IsPacked", "IsWeak", "IsList", "IsMap", "MapKey", "MapValue", "HasDefault", "Default", "ContainingOneof", "ContainingMessage", "Message", "Enum"},
reflect.TypeOf((*pref.OneofDescriptor)(nil)).Elem(): {"Fields"}, // not directly used; must keep in sync with formatDescOpt reflect.TypeOf((*protoreflect.OneofDescriptor)(nil)).Elem(): {"Fields"}, // not directly used; must keep in sync with formatDescOpt
reflect.TypeOf((*pref.EnumDescriptor)(nil)).Elem(): {"Values", "ReservedNames", "ReservedRanges"}, reflect.TypeOf((*protoreflect.EnumDescriptor)(nil)).Elem(): {"Values", "ReservedNames", "ReservedRanges"},
reflect.TypeOf((*pref.EnumValueDescriptor)(nil)).Elem(): {"Number"}, reflect.TypeOf((*protoreflect.EnumValueDescriptor)(nil)).Elem(): {"Number"},
reflect.TypeOf((*pref.ServiceDescriptor)(nil)).Elem(): {"Methods"}, reflect.TypeOf((*protoreflect.ServiceDescriptor)(nil)).Elem(): {"Methods"},
reflect.TypeOf((*pref.MethodDescriptor)(nil)).Elem(): {"Input", "Output", "IsStreamingClient", "IsStreamingServer"}, reflect.TypeOf((*protoreflect.MethodDescriptor)(nil)).Elem(): {"Input", "Output", "IsStreamingClient", "IsStreamingServer"},
} }
func FormatDesc(s fmt.State, r rune, t pref.Descriptor) { func FormatDesc(s fmt.State, r rune, t protoreflect.Descriptor) {
io.WriteString(s, formatDescOpt(t, true, r == 'v' && (s.Flag('+') || s.Flag('#')))) io.WriteString(s, formatDescOpt(t, true, r == 'v' && (s.Flag('+') || s.Flag('#'))))
} }
func formatDescOpt(t pref.Descriptor, isRoot, allowMulti bool) string { func formatDescOpt(t protoreflect.Descriptor, isRoot, allowMulti bool) string {
rv := reflect.ValueOf(t) rv := reflect.ValueOf(t)
rt := rv.MethodByName("ProtoType").Type().In(0) rt := rv.MethodByName("ProtoType").Type().In(0)
@ -128,7 +128,7 @@ func formatDescOpt(t pref.Descriptor, isRoot, allowMulti bool) string {
start = rt.Name() + "{" start = rt.Name() + "{"
} }
_, isFile := t.(pref.FileDescriptor) _, isFile := t.(protoreflect.FileDescriptor)
rs := records{allowMulti: allowMulti} rs := records{allowMulti: allowMulti}
if t.IsPlaceholder() { if t.IsPlaceholder() {
if isFile { if isFile {
@ -146,7 +146,7 @@ func formatDescOpt(t pref.Descriptor, isRoot, allowMulti bool) string {
rs.Append(rv, "Name") rs.Append(rv, "Name")
} }
switch t := t.(type) { switch t := t.(type) {
case pref.FieldDescriptor: case protoreflect.FieldDescriptor:
for _, s := range descriptorAccessors[rt] { for _, s := range descriptorAccessors[rt] {
switch s { switch s {
case "MapKey": case "MapKey":
@ -156,9 +156,9 @@ func formatDescOpt(t pref.Descriptor, isRoot, allowMulti bool) string {
case "MapValue": case "MapValue":
if v := t.MapValue(); v != nil { if v := t.MapValue(); v != nil {
switch v.Kind() { switch v.Kind() {
case pref.EnumKind: case protoreflect.EnumKind:
rs.recs = append(rs.recs, [2]string{"MapValue", string(v.Enum().FullName())}) rs.recs = append(rs.recs, [2]string{"MapValue", string(v.Enum().FullName())})
case pref.MessageKind, pref.GroupKind: case protoreflect.MessageKind, protoreflect.GroupKind:
rs.recs = append(rs.recs, [2]string{"MapValue", string(v.Message().FullName())}) rs.recs = append(rs.recs, [2]string{"MapValue", string(v.Message().FullName())})
default: default:
rs.recs = append(rs.recs, [2]string{"MapValue", v.Kind().String()}) rs.recs = append(rs.recs, [2]string{"MapValue", v.Kind().String()})
@ -180,7 +180,7 @@ func formatDescOpt(t pref.Descriptor, isRoot, allowMulti bool) string {
rs.Append(rv, s) rs.Append(rv, s)
} }
} }
case pref.OneofDescriptor: case protoreflect.OneofDescriptor:
var ss []string var ss []string
fs := t.Fields() fs := t.Fields()
for i := 0; i < fs.Len(); i++ { for i := 0; i < fs.Len(); i++ {
@ -216,7 +216,7 @@ func (rs *records) Append(v reflect.Value, accessors ...string) {
if !rv.IsValid() { if !rv.IsValid() {
panic(fmt.Sprintf("unknown accessor: %v.%s", v.Type(), a)) panic(fmt.Sprintf("unknown accessor: %v.%s", v.Type(), a))
} }
if _, ok := rv.Interface().(pref.Value); ok { if _, ok := rv.Interface().(protoreflect.Value); ok {
rv = rv.MethodByName("Interface").Call(nil)[0] rv = rv.MethodByName("Interface").Call(nil)[0]
if !rv.IsNil() { if !rv.IsNil() {
rv = rv.Elem() rv = rv.Elem()
@ -250,9 +250,9 @@ func (rs *records) Append(v reflect.Value, accessors ...string) {
switch v := v.(type) { switch v := v.(type) {
case list: case list:
s = formatListOpt(v, false, rs.allowMulti) s = formatListOpt(v, false, rs.allowMulti)
case pref.FieldDescriptor, pref.OneofDescriptor, pref.EnumValueDescriptor, pref.MethodDescriptor: case protoreflect.FieldDescriptor, protoreflect.OneofDescriptor, protoreflect.EnumValueDescriptor, protoreflect.MethodDescriptor:
s = string(v.(pref.Descriptor).Name()) s = string(v.(protoreflect.Descriptor).Name())
case pref.Descriptor: case protoreflect.Descriptor:
s = string(v.FullName()) s = string(v.FullName())
case string: case string:
s = strconv.Quote(v) s = strconv.Quote(v)

View File

@ -15,8 +15,8 @@ import (
"strconv" "strconv"
ptext "google.golang.org/protobuf/internal/encoding/text" ptext "google.golang.org/protobuf/internal/encoding/text"
errors "google.golang.org/protobuf/internal/errors" "google.golang.org/protobuf/internal/errors"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
// Format is the serialization format used to represent the default value. // Format is the serialization format used to represent the default value.
@ -35,56 +35,56 @@ const (
// Unmarshal deserializes the default string s according to the given kind k. // Unmarshal deserializes the default string s according to the given kind k.
// When k is an enum, a list of enum value descriptors must be provided. // When k is an enum, a list of enum value descriptors must be provided.
func Unmarshal(s string, k pref.Kind, evs pref.EnumValueDescriptors, f Format) (pref.Value, pref.EnumValueDescriptor, error) { func Unmarshal(s string, k protoreflect.Kind, evs protoreflect.EnumValueDescriptors, f Format) (protoreflect.Value, protoreflect.EnumValueDescriptor, error) {
switch k { switch k {
case pref.BoolKind: case protoreflect.BoolKind:
if f == GoTag { if f == GoTag {
switch s { switch s {
case "1": case "1":
return pref.ValueOfBool(true), nil, nil return protoreflect.ValueOfBool(true), nil, nil
case "0": case "0":
return pref.ValueOfBool(false), nil, nil return protoreflect.ValueOfBool(false), nil, nil
} }
} else { } else {
switch s { switch s {
case "true": case "true":
return pref.ValueOfBool(true), nil, nil return protoreflect.ValueOfBool(true), nil, nil
case "false": case "false":
return pref.ValueOfBool(false), nil, nil return protoreflect.ValueOfBool(false), nil, nil
} }
} }
case pref.EnumKind: case protoreflect.EnumKind:
if f == GoTag { if f == GoTag {
// Go tags use the numeric form of the enum value. // Go tags use the numeric form of the enum value.
if n, err := strconv.ParseInt(s, 10, 32); err == nil { if n, err := strconv.ParseInt(s, 10, 32); err == nil {
if ev := evs.ByNumber(pref.EnumNumber(n)); ev != nil { if ev := evs.ByNumber(protoreflect.EnumNumber(n)); ev != nil {
return pref.ValueOfEnum(ev.Number()), ev, nil return protoreflect.ValueOfEnum(ev.Number()), ev, nil
} }
} }
} else { } else {
// Descriptor default_value use the enum identifier. // Descriptor default_value use the enum identifier.
ev := evs.ByName(pref.Name(s)) ev := evs.ByName(protoreflect.Name(s))
if ev != nil { if ev != nil {
return pref.ValueOfEnum(ev.Number()), ev, nil return protoreflect.ValueOfEnum(ev.Number()), ev, nil
} }
} }
case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind: case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
if v, err := strconv.ParseInt(s, 10, 32); err == nil { if v, err := strconv.ParseInt(s, 10, 32); err == nil {
return pref.ValueOfInt32(int32(v)), nil, nil return protoreflect.ValueOfInt32(int32(v)), nil, nil
} }
case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind: case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
if v, err := strconv.ParseInt(s, 10, 64); err == nil { if v, err := strconv.ParseInt(s, 10, 64); err == nil {
return pref.ValueOfInt64(int64(v)), nil, nil return protoreflect.ValueOfInt64(int64(v)), nil, nil
} }
case pref.Uint32Kind, pref.Fixed32Kind: case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
if v, err := strconv.ParseUint(s, 10, 32); err == nil { if v, err := strconv.ParseUint(s, 10, 32); err == nil {
return pref.ValueOfUint32(uint32(v)), nil, nil return protoreflect.ValueOfUint32(uint32(v)), nil, nil
} }
case pref.Uint64Kind, pref.Fixed64Kind: case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
if v, err := strconv.ParseUint(s, 10, 64); err == nil { if v, err := strconv.ParseUint(s, 10, 64); err == nil {
return pref.ValueOfUint64(uint64(v)), nil, nil return protoreflect.ValueOfUint64(uint64(v)), nil, nil
} }
case pref.FloatKind, pref.DoubleKind: case protoreflect.FloatKind, protoreflect.DoubleKind:
var v float64 var v float64
var err error var err error
switch s { switch s {
@ -98,29 +98,29 @@ func Unmarshal(s string, k pref.Kind, evs pref.EnumValueDescriptors, f Format) (
v, err = strconv.ParseFloat(s, 64) v, err = strconv.ParseFloat(s, 64)
} }
if err == nil { if err == nil {
if k == pref.FloatKind { if k == protoreflect.FloatKind {
return pref.ValueOfFloat32(float32(v)), nil, nil return protoreflect.ValueOfFloat32(float32(v)), nil, nil
} else { } else {
return pref.ValueOfFloat64(float64(v)), nil, nil return protoreflect.ValueOfFloat64(float64(v)), nil, nil
} }
} }
case pref.StringKind: case protoreflect.StringKind:
// String values are already unescaped and can be used as is. // String values are already unescaped and can be used as is.
return pref.ValueOfString(s), nil, nil return protoreflect.ValueOfString(s), nil, nil
case pref.BytesKind: case protoreflect.BytesKind:
if b, ok := unmarshalBytes(s); ok { if b, ok := unmarshalBytes(s); ok {
return pref.ValueOfBytes(b), nil, nil return protoreflect.ValueOfBytes(b), nil, nil
} }
} }
return pref.Value{}, nil, errors.New("could not parse value for %v: %q", k, s) return protoreflect.Value{}, nil, errors.New("could not parse value for %v: %q", k, s)
} }
// Marshal serializes v as the default string according to the given kind k. // Marshal serializes v as the default string according to the given kind k.
// When specifying the Descriptor format for an enum kind, the associated // When specifying the Descriptor format for an enum kind, the associated
// enum value descriptor must be provided. // enum value descriptor must be provided.
func Marshal(v pref.Value, ev pref.EnumValueDescriptor, k pref.Kind, f Format) (string, error) { func Marshal(v protoreflect.Value, ev protoreflect.EnumValueDescriptor, k protoreflect.Kind, f Format) (string, error) {
switch k { switch k {
case pref.BoolKind: case protoreflect.BoolKind:
if f == GoTag { if f == GoTag {
if v.Bool() { if v.Bool() {
return "1", nil return "1", nil
@ -134,17 +134,17 @@ func Marshal(v pref.Value, ev pref.EnumValueDescriptor, k pref.Kind, f Format) (
return "false", nil return "false", nil
} }
} }
case pref.EnumKind: case protoreflect.EnumKind:
if f == GoTag { if f == GoTag {
return strconv.FormatInt(int64(v.Enum()), 10), nil return strconv.FormatInt(int64(v.Enum()), 10), nil
} else { } else {
return string(ev.Name()), nil return string(ev.Name()), nil
} }
case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind, pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind: case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind, protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
return strconv.FormatInt(v.Int(), 10), nil return strconv.FormatInt(v.Int(), 10), nil
case pref.Uint32Kind, pref.Fixed32Kind, pref.Uint64Kind, pref.Fixed64Kind: case protoreflect.Uint32Kind, protoreflect.Fixed32Kind, protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
return strconv.FormatUint(v.Uint(), 10), nil return strconv.FormatUint(v.Uint(), 10), nil
case pref.FloatKind, pref.DoubleKind: case protoreflect.FloatKind, protoreflect.DoubleKind:
f := v.Float() f := v.Float()
switch { switch {
case math.IsInf(f, -1): case math.IsInf(f, -1):
@ -154,16 +154,16 @@ func Marshal(v pref.Value, ev pref.EnumValueDescriptor, k pref.Kind, f Format) (
case math.IsNaN(f): case math.IsNaN(f):
return "nan", nil return "nan", nil
default: default:
if k == pref.FloatKind { if k == protoreflect.FloatKind {
return strconv.FormatFloat(f, 'g', -1, 32), nil return strconv.FormatFloat(f, 'g', -1, 32), nil
} else { } else {
return strconv.FormatFloat(f, 'g', -1, 64), nil return strconv.FormatFloat(f, 'g', -1, 64), nil
} }
} }
case pref.StringKind: case protoreflect.StringKind:
// String values are serialized as is without any escaping. // String values are serialized as is without any escaping.
return v.String(), nil return v.String(), nil
case pref.BytesKind: case protoreflect.BytesKind:
if s, ok := marshalBytes(v.Bytes()); ok { if s, ok := marshalBytes(v.Bytes()); ok {
return s, nil return s, nil
} }

View File

@ -10,7 +10,7 @@ import (
"google.golang.org/protobuf/encoding/protowire" "google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/errors" "google.golang.org/protobuf/internal/errors"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
// The MessageSet wire format is equivalent to a message defined as follows, // The MessageSet wire format is equivalent to a message defined as follows,
@ -33,6 +33,7 @@ const (
// ExtensionName is the field name for extensions of MessageSet. // ExtensionName is the field name for extensions of MessageSet.
// //
// A valid MessageSet extension must be of the form: // A valid MessageSet extension must be of the form:
//
// message MyMessage { // message MyMessage {
// extend proto2.bridge.MessageSet { // extend proto2.bridge.MessageSet {
// optional MyMessage message_set_extension = 1234; // optional MyMessage message_set_extension = 1234;
@ -42,13 +43,13 @@ const (
const ExtensionName = "message_set_extension" const ExtensionName = "message_set_extension"
// IsMessageSet returns whether the message uses the MessageSet wire format. // IsMessageSet returns whether the message uses the MessageSet wire format.
func IsMessageSet(md pref.MessageDescriptor) bool { func IsMessageSet(md protoreflect.MessageDescriptor) bool {
xmd, ok := md.(interface{ IsMessageSet() bool }) xmd, ok := md.(interface{ IsMessageSet() bool })
return ok && xmd.IsMessageSet() return ok && xmd.IsMessageSet()
} }
// IsMessageSetExtension reports this field properly extends a MessageSet. // IsMessageSetExtension reports this field properly extends a MessageSet.
func IsMessageSetExtension(fd pref.FieldDescriptor) bool { func IsMessageSetExtension(fd protoreflect.FieldDescriptor) bool {
switch { switch {
case fd.Name() != ExtensionName: case fd.Name() != ExtensionName:
return false return false

View File

@ -11,10 +11,10 @@ import (
"strconv" "strconv"
"strings" "strings"
defval "google.golang.org/protobuf/internal/encoding/defval" "google.golang.org/protobuf/internal/encoding/defval"
fdesc "google.golang.org/protobuf/internal/filedesc" "google.golang.org/protobuf/internal/filedesc"
"google.golang.org/protobuf/internal/strs" "google.golang.org/protobuf/internal/strs"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
var byteType = reflect.TypeOf(byte(0)) var byteType = reflect.TypeOf(byte(0))
@ -29,9 +29,9 @@ var byteType = reflect.TypeOf(byte(0))
// This does not populate the Enum or Message (except for weak message). // This does not populate the Enum or Message (except for weak message).
// //
// This function is a best effort attempt; parsing errors are ignored. // This function is a best effort attempt; parsing errors are ignored.
func Unmarshal(tag string, goType reflect.Type, evs pref.EnumValueDescriptors) pref.FieldDescriptor { func Unmarshal(tag string, goType reflect.Type, evs protoreflect.EnumValueDescriptors) protoreflect.FieldDescriptor {
f := new(fdesc.Field) f := new(filedesc.Field)
f.L0.ParentFile = fdesc.SurrogateProto2 f.L0.ParentFile = filedesc.SurrogateProto2
for len(tag) > 0 { for len(tag) > 0 {
i := strings.IndexByte(tag, ',') i := strings.IndexByte(tag, ',')
if i < 0 { if i < 0 {
@ -39,68 +39,68 @@ func Unmarshal(tag string, goType reflect.Type, evs pref.EnumValueDescriptors) p
} }
switch s := tag[:i]; { switch s := tag[:i]; {
case strings.HasPrefix(s, "name="): case strings.HasPrefix(s, "name="):
f.L0.FullName = pref.FullName(s[len("name="):]) f.L0.FullName = protoreflect.FullName(s[len("name="):])
case strings.Trim(s, "0123456789") == "": case strings.Trim(s, "0123456789") == "":
n, _ := strconv.ParseUint(s, 10, 32) n, _ := strconv.ParseUint(s, 10, 32)
f.L1.Number = pref.FieldNumber(n) f.L1.Number = protoreflect.FieldNumber(n)
case s == "opt": case s == "opt":
f.L1.Cardinality = pref.Optional f.L1.Cardinality = protoreflect.Optional
case s == "req": case s == "req":
f.L1.Cardinality = pref.Required f.L1.Cardinality = protoreflect.Required
case s == "rep": case s == "rep":
f.L1.Cardinality = pref.Repeated f.L1.Cardinality = protoreflect.Repeated
case s == "varint": case s == "varint":
switch goType.Kind() { switch goType.Kind() {
case reflect.Bool: case reflect.Bool:
f.L1.Kind = pref.BoolKind f.L1.Kind = protoreflect.BoolKind
case reflect.Int32: case reflect.Int32:
f.L1.Kind = pref.Int32Kind f.L1.Kind = protoreflect.Int32Kind
case reflect.Int64: case reflect.Int64:
f.L1.Kind = pref.Int64Kind f.L1.Kind = protoreflect.Int64Kind
case reflect.Uint32: case reflect.Uint32:
f.L1.Kind = pref.Uint32Kind f.L1.Kind = protoreflect.Uint32Kind
case reflect.Uint64: case reflect.Uint64:
f.L1.Kind = pref.Uint64Kind f.L1.Kind = protoreflect.Uint64Kind
} }
case s == "zigzag32": case s == "zigzag32":
if goType.Kind() == reflect.Int32 { if goType.Kind() == reflect.Int32 {
f.L1.Kind = pref.Sint32Kind f.L1.Kind = protoreflect.Sint32Kind
} }
case s == "zigzag64": case s == "zigzag64":
if goType.Kind() == reflect.Int64 { if goType.Kind() == reflect.Int64 {
f.L1.Kind = pref.Sint64Kind f.L1.Kind = protoreflect.Sint64Kind
} }
case s == "fixed32": case s == "fixed32":
switch goType.Kind() { switch goType.Kind() {
case reflect.Int32: case reflect.Int32:
f.L1.Kind = pref.Sfixed32Kind f.L1.Kind = protoreflect.Sfixed32Kind
case reflect.Uint32: case reflect.Uint32:
f.L1.Kind = pref.Fixed32Kind f.L1.Kind = protoreflect.Fixed32Kind
case reflect.Float32: case reflect.Float32:
f.L1.Kind = pref.FloatKind f.L1.Kind = protoreflect.FloatKind
} }
case s == "fixed64": case s == "fixed64":
switch goType.Kind() { switch goType.Kind() {
case reflect.Int64: case reflect.Int64:
f.L1.Kind = pref.Sfixed64Kind f.L1.Kind = protoreflect.Sfixed64Kind
case reflect.Uint64: case reflect.Uint64:
f.L1.Kind = pref.Fixed64Kind f.L1.Kind = protoreflect.Fixed64Kind
case reflect.Float64: case reflect.Float64:
f.L1.Kind = pref.DoubleKind f.L1.Kind = protoreflect.DoubleKind
} }
case s == "bytes": case s == "bytes":
switch { switch {
case goType.Kind() == reflect.String: case goType.Kind() == reflect.String:
f.L1.Kind = pref.StringKind f.L1.Kind = protoreflect.StringKind
case goType.Kind() == reflect.Slice && goType.Elem() == byteType: case goType.Kind() == reflect.Slice && goType.Elem() == byteType:
f.L1.Kind = pref.BytesKind f.L1.Kind = protoreflect.BytesKind
default: default:
f.L1.Kind = pref.MessageKind f.L1.Kind = protoreflect.MessageKind
} }
case s == "group": case s == "group":
f.L1.Kind = pref.GroupKind f.L1.Kind = protoreflect.GroupKind
case strings.HasPrefix(s, "enum="): case strings.HasPrefix(s, "enum="):
f.L1.Kind = pref.EnumKind f.L1.Kind = protoreflect.EnumKind
case strings.HasPrefix(s, "json="): case strings.HasPrefix(s, "json="):
jsonName := s[len("json="):] jsonName := s[len("json="):]
if jsonName != strs.JSONCamelCase(string(f.L0.FullName.Name())) { if jsonName != strs.JSONCamelCase(string(f.L0.FullName.Name())) {
@ -111,23 +111,23 @@ func Unmarshal(tag string, goType reflect.Type, evs pref.EnumValueDescriptors) p
f.L1.IsPacked = true f.L1.IsPacked = true
case strings.HasPrefix(s, "weak="): case strings.HasPrefix(s, "weak="):
f.L1.IsWeak = true f.L1.IsWeak = true
f.L1.Message = fdesc.PlaceholderMessage(pref.FullName(s[len("weak="):])) f.L1.Message = filedesc.PlaceholderMessage(protoreflect.FullName(s[len("weak="):]))
case strings.HasPrefix(s, "def="): case strings.HasPrefix(s, "def="):
// The default tag is special in that everything afterwards is the // The default tag is special in that everything afterwards is the
// default regardless of the presence of commas. // default regardless of the presence of commas.
s, i = tag[len("def="):], len(tag) s, i = tag[len("def="):], len(tag)
v, ev, _ := defval.Unmarshal(s, f.L1.Kind, evs, defval.GoTag) v, ev, _ := defval.Unmarshal(s, f.L1.Kind, evs, defval.GoTag)
f.L1.Default = fdesc.DefaultValue(v, ev) f.L1.Default = filedesc.DefaultValue(v, ev)
case s == "proto3": case s == "proto3":
f.L0.ParentFile = fdesc.SurrogateProto3 f.L0.ParentFile = filedesc.SurrogateProto3
} }
tag = strings.TrimPrefix(tag[i:], ",") tag = strings.TrimPrefix(tag[i:], ",")
} }
// The generator uses the group message name instead of the field name. // The generator uses the group message name instead of the field name.
// We obtain the real field name by lowercasing the group name. // We obtain the real field name by lowercasing the group name.
if f.L1.Kind == pref.GroupKind { if f.L1.Kind == protoreflect.GroupKind {
f.L0.FullName = pref.FullName(strings.ToLower(string(f.L0.FullName))) f.L0.FullName = protoreflect.FullName(strings.ToLower(string(f.L0.FullName)))
} }
return f return f
} }
@ -140,38 +140,38 @@ func Unmarshal(tag string, goType reflect.Type, evs pref.EnumValueDescriptors) p
// Depending on the context on how Marshal is called, there are different ways // Depending on the context on how Marshal is called, there are different ways
// through which that information is determined. As such it is the caller's // through which that information is determined. As such it is the caller's
// responsibility to provide a function to obtain that information. // responsibility to provide a function to obtain that information.
func Marshal(fd pref.FieldDescriptor, enumName string) string { func Marshal(fd protoreflect.FieldDescriptor, enumName string) string {
var tag []string var tag []string
switch fd.Kind() { switch fd.Kind() {
case pref.BoolKind, pref.EnumKind, pref.Int32Kind, pref.Uint32Kind, pref.Int64Kind, pref.Uint64Kind: case protoreflect.BoolKind, protoreflect.EnumKind, protoreflect.Int32Kind, protoreflect.Uint32Kind, protoreflect.Int64Kind, protoreflect.Uint64Kind:
tag = append(tag, "varint") tag = append(tag, "varint")
case pref.Sint32Kind: case protoreflect.Sint32Kind:
tag = append(tag, "zigzag32") tag = append(tag, "zigzag32")
case pref.Sint64Kind: case protoreflect.Sint64Kind:
tag = append(tag, "zigzag64") tag = append(tag, "zigzag64")
case pref.Sfixed32Kind, pref.Fixed32Kind, pref.FloatKind: case protoreflect.Sfixed32Kind, protoreflect.Fixed32Kind, protoreflect.FloatKind:
tag = append(tag, "fixed32") tag = append(tag, "fixed32")
case pref.Sfixed64Kind, pref.Fixed64Kind, pref.DoubleKind: case protoreflect.Sfixed64Kind, protoreflect.Fixed64Kind, protoreflect.DoubleKind:
tag = append(tag, "fixed64") tag = append(tag, "fixed64")
case pref.StringKind, pref.BytesKind, pref.MessageKind: case protoreflect.StringKind, protoreflect.BytesKind, protoreflect.MessageKind:
tag = append(tag, "bytes") tag = append(tag, "bytes")
case pref.GroupKind: case protoreflect.GroupKind:
tag = append(tag, "group") tag = append(tag, "group")
} }
tag = append(tag, strconv.Itoa(int(fd.Number()))) tag = append(tag, strconv.Itoa(int(fd.Number())))
switch fd.Cardinality() { switch fd.Cardinality() {
case pref.Optional: case protoreflect.Optional:
tag = append(tag, "opt") tag = append(tag, "opt")
case pref.Required: case protoreflect.Required:
tag = append(tag, "req") tag = append(tag, "req")
case pref.Repeated: case protoreflect.Repeated:
tag = append(tag, "rep") tag = append(tag, "rep")
} }
if fd.IsPacked() { if fd.IsPacked() {
tag = append(tag, "packed") tag = append(tag, "packed")
} }
name := string(fd.Name()) name := string(fd.Name())
if fd.Kind() == pref.GroupKind { if fd.Kind() == protoreflect.GroupKind {
// The name of the FieldDescriptor for a group field is // The name of the FieldDescriptor for a group field is
// lowercased. To find the original capitalization, we // lowercased. To find the original capitalization, we
// look in the field's MessageType. // look in the field's MessageType.
@ -189,10 +189,10 @@ func Marshal(fd pref.FieldDescriptor, enumName string) string {
// The previous implementation does not tag extension fields as proto3, // The previous implementation does not tag extension fields as proto3,
// even when the field is defined in a proto3 file. Match that behavior // even when the field is defined in a proto3 file. Match that behavior
// for consistency. // for consistency.
if fd.Syntax() == pref.Proto3 && !fd.IsExtension() { if fd.Syntax() == protoreflect.Proto3 && !fd.IsExtension() {
tag = append(tag, "proto3") tag = append(tag, "proto3")
} }
if fd.Kind() == pref.EnumKind && enumName != "" { if fd.Kind() == protoreflect.EnumKind && enumName != "" {
tag = append(tag, "enum="+enumName) tag = append(tag, "enum="+enumName)
} }
if fd.ContainingOneof() != nil { if fd.ContainingOneof() != nil {

View File

@ -8,7 +8,6 @@ import (
"bytes" "bytes"
"fmt" "fmt"
"io" "io"
"regexp"
"strconv" "strconv"
"unicode/utf8" "unicode/utf8"
@ -421,7 +420,7 @@ func (d *Decoder) parseFieldName() (tok Token, err error) {
return Token{}, d.newSyntaxError("invalid field number: %s", d.in[:num.size]) return Token{}, d.newSyntaxError("invalid field number: %s", d.in[:num.size])
} }
return Token{}, d.newSyntaxError("invalid field name: %s", errRegexp.Find(d.in)) return Token{}, d.newSyntaxError("invalid field name: %s", errId(d.in))
} }
// parseTypeName parses Any type URL or extension field name. The name is // parseTypeName parses Any type URL or extension field name. The name is
@ -571,7 +570,7 @@ func (d *Decoder) parseScalar() (Token, error) {
return tok, nil return tok, nil
} }
return Token{}, d.newSyntaxError("invalid scalar value: %s", errRegexp.Find(d.in)) return Token{}, d.newSyntaxError("invalid scalar value: %s", errId(d.in))
} }
// parseLiteralValue parses a literal value. A literal value is used for // parseLiteralValue parses a literal value. A literal value is used for
@ -653,8 +652,29 @@ func consume(b []byte, n int) []byte {
return b return b
} }
// Any sequence that looks like a non-delimiter (for error reporting). // errId extracts a byte sequence that looks like an invalid ID
var errRegexp = regexp.MustCompile(`^([-+._a-zA-Z0-9\/]+|.)`) // (for the purposes of error reporting).
func errId(seq []byte) []byte {
const maxLen = 32
for i := 0; i < len(seq); {
if i > maxLen {
return append(seq[:i:i], "…"...)
}
r, size := utf8.DecodeRune(seq[i:])
if r > utf8.RuneSelf || (r != '/' && isDelim(byte(r))) {
if i == 0 {
// Either the first byte is invalid UTF-8 or a
// delimiter, or the first rune is non-ASCII.
// Return it as-is.
i = size
}
return seq[:i:i]
}
i += size
}
// No delimiter found.
return seq
}
// isDelim returns true if given byte is a delimiter character. // isDelim returns true if given byte is a delimiter character.
func isDelim(c byte) bool { func isDelim(c byte) bool {

View File

@ -50,8 +50,10 @@ type number struct {
// parseNumber constructs a number object from given input. It allows for the // parseNumber constructs a number object from given input. It allows for the
// following patterns: // following patterns:
//
// integer: ^-?([1-9][0-9]*|0[xX][0-9a-fA-F]+|0[0-7]*) // integer: ^-?([1-9][0-9]*|0[xX][0-9a-fA-F]+|0[0-7]*)
// float: ^-?((0|[1-9][0-9]*)?([.][0-9]*)?([eE][+-]?[0-9]+)?[fF]?) // float: ^-?((0|[1-9][0-9]*)?([.][0-9]*)?([eE][+-]?[0-9]+)?[fF]?)
//
// It also returns the number of parsed bytes for the given number, 0 if it is // It also returns the number of parsed bytes for the given number, 0 if it is
// not a number. // not a number.
func parseNumber(input []byte) number { func parseNumber(input []byte) number {

View File

@ -24,6 +24,6 @@
// the Go implementation should as well. // the Go implementation should as well.
// //
// The text format is almost a superset of JSON except: // The text format is almost a superset of JSON except:
// * message keys are not quoted strings, but identifiers // - message keys are not quoted strings, but identifiers
// * the top-level value must be a message without the delimiters // - the top-level value must be a message without the delimiters
package text package text

View File

@ -12,8 +12,7 @@ import (
"google.golang.org/protobuf/encoding/protowire" "google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/genid" "google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoregistry"
preg "google.golang.org/protobuf/reflect/protoregistry"
) )
// Builder construct a protoreflect.FileDescriptor from the raw descriptor. // Builder construct a protoreflect.FileDescriptor from the raw descriptor.
@ -38,7 +37,7 @@ type Builder struct {
// TypeResolver resolves extension field types for descriptor options. // TypeResolver resolves extension field types for descriptor options.
// If nil, it uses protoregistry.GlobalTypes. // If nil, it uses protoregistry.GlobalTypes.
TypeResolver interface { TypeResolver interface {
preg.ExtensionTypeResolver protoregistry.ExtensionTypeResolver
} }
// FileRegistry is use to lookup file, enum, and message dependencies. // FileRegistry is use to lookup file, enum, and message dependencies.
@ -46,8 +45,8 @@ type Builder struct {
// If nil, it uses protoregistry.GlobalFiles. // If nil, it uses protoregistry.GlobalFiles.
FileRegistry interface { FileRegistry interface {
FindFileByPath(string) (protoreflect.FileDescriptor, error) FindFileByPath(string) (protoreflect.FileDescriptor, error)
FindDescriptorByName(pref.FullName) (pref.Descriptor, error) FindDescriptorByName(protoreflect.FullName) (protoreflect.Descriptor, error)
RegisterFile(pref.FileDescriptor) error RegisterFile(protoreflect.FileDescriptor) error
} }
} }
@ -55,8 +54,8 @@ type Builder struct {
// If so, it permits looking up an enum or message dependency based on the // If so, it permits looking up an enum or message dependency based on the
// sub-list and element index into filetype.Builder.DependencyIndexes. // sub-list and element index into filetype.Builder.DependencyIndexes.
type resolverByIndex interface { type resolverByIndex interface {
FindEnumByIndex(int32, int32, []Enum, []Message) pref.EnumDescriptor FindEnumByIndex(int32, int32, []Enum, []Message) protoreflect.EnumDescriptor
FindMessageByIndex(int32, int32, []Enum, []Message) pref.MessageDescriptor FindMessageByIndex(int32, int32, []Enum, []Message) protoreflect.MessageDescriptor
} }
// Indexes of each sub-list in filetype.Builder.DependencyIndexes. // Indexes of each sub-list in filetype.Builder.DependencyIndexes.
@ -70,7 +69,7 @@ const (
// Out is the output of the Builder. // Out is the output of the Builder.
type Out struct { type Out struct {
File pref.FileDescriptor File protoreflect.FileDescriptor
// Enums is all enum descriptors in "flattened ordering". // Enums is all enum descriptors in "flattened ordering".
Enums []Enum Enums []Enum
@ -97,10 +96,10 @@ func (db Builder) Build() (out Out) {
// Initialize resolvers and registries if unpopulated. // Initialize resolvers and registries if unpopulated.
if db.TypeResolver == nil { if db.TypeResolver == nil {
db.TypeResolver = preg.GlobalTypes db.TypeResolver = protoregistry.GlobalTypes
} }
if db.FileRegistry == nil { if db.FileRegistry == nil {
db.FileRegistry = preg.GlobalFiles db.FileRegistry = protoregistry.GlobalFiles
} }
fd := newRawFile(db) fd := newRawFile(db)

View File

@ -17,7 +17,7 @@ import (
"google.golang.org/protobuf/internal/genid" "google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/internal/pragma" "google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/internal/strs" "google.golang.org/protobuf/internal/strs"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry" "google.golang.org/protobuf/reflect/protoregistry"
) )
@ -43,9 +43,9 @@ type (
L2 *FileL2 L2 *FileL2
} }
FileL1 struct { FileL1 struct {
Syntax pref.Syntax Syntax protoreflect.Syntax
Path string Path string
Package pref.FullName Package protoreflect.FullName
Enums Enums Enums Enums
Messages Messages Messages Messages
@ -53,35 +53,35 @@ type (
Services Services Services Services
} }
FileL2 struct { FileL2 struct {
Options func() pref.ProtoMessage Options func() protoreflect.ProtoMessage
Imports FileImports Imports FileImports
Locations SourceLocations Locations SourceLocations
} }
) )
func (fd *File) ParentFile() pref.FileDescriptor { return fd } func (fd *File) ParentFile() protoreflect.FileDescriptor { return fd }
func (fd *File) Parent() pref.Descriptor { return nil } func (fd *File) Parent() protoreflect.Descriptor { return nil }
func (fd *File) Index() int { return 0 } func (fd *File) Index() int { return 0 }
func (fd *File) Syntax() pref.Syntax { return fd.L1.Syntax } func (fd *File) Syntax() protoreflect.Syntax { return fd.L1.Syntax }
func (fd *File) Name() pref.Name { return fd.L1.Package.Name() } func (fd *File) Name() protoreflect.Name { return fd.L1.Package.Name() }
func (fd *File) FullName() pref.FullName { return fd.L1.Package } func (fd *File) FullName() protoreflect.FullName { return fd.L1.Package }
func (fd *File) IsPlaceholder() bool { return false } func (fd *File) IsPlaceholder() bool { return false }
func (fd *File) Options() pref.ProtoMessage { func (fd *File) Options() protoreflect.ProtoMessage {
if f := fd.lazyInit().Options; f != nil { if f := fd.lazyInit().Options; f != nil {
return f() return f()
} }
return descopts.File return descopts.File
} }
func (fd *File) Path() string { return fd.L1.Path } func (fd *File) Path() string { return fd.L1.Path }
func (fd *File) Package() pref.FullName { return fd.L1.Package } func (fd *File) Package() protoreflect.FullName { return fd.L1.Package }
func (fd *File) Imports() pref.FileImports { return &fd.lazyInit().Imports } func (fd *File) Imports() protoreflect.FileImports { return &fd.lazyInit().Imports }
func (fd *File) Enums() pref.EnumDescriptors { return &fd.L1.Enums } func (fd *File) Enums() protoreflect.EnumDescriptors { return &fd.L1.Enums }
func (fd *File) Messages() pref.MessageDescriptors { return &fd.L1.Messages } func (fd *File) Messages() protoreflect.MessageDescriptors { return &fd.L1.Messages }
func (fd *File) Extensions() pref.ExtensionDescriptors { return &fd.L1.Extensions } func (fd *File) Extensions() protoreflect.ExtensionDescriptors { return &fd.L1.Extensions }
func (fd *File) Services() pref.ServiceDescriptors { return &fd.L1.Services } func (fd *File) Services() protoreflect.ServiceDescriptors { return &fd.L1.Services }
func (fd *File) SourceLocations() pref.SourceLocations { return &fd.lazyInit().Locations } func (fd *File) SourceLocations() protoreflect.SourceLocations { return &fd.lazyInit().Locations }
func (fd *File) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, fd) } func (fd *File) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, fd) }
func (fd *File) ProtoType(pref.FileDescriptor) {} func (fd *File) ProtoType(protoreflect.FileDescriptor) {}
func (fd *File) ProtoInternal(pragma.DoNotImplement) {} func (fd *File) ProtoInternal(pragma.DoNotImplement) {}
func (fd *File) lazyInit() *FileL2 { func (fd *File) lazyInit() *FileL2 {
@ -119,7 +119,7 @@ type (
eagerValues bool // controls whether EnumL2.Values is already populated eagerValues bool // controls whether EnumL2.Values is already populated
} }
EnumL2 struct { EnumL2 struct {
Options func() pref.ProtoMessage Options func() protoreflect.ProtoMessage
Values EnumValues Values EnumValues
ReservedNames Names ReservedNames Names
ReservedRanges EnumRanges ReservedRanges EnumRanges
@ -130,41 +130,41 @@ type (
L1 EnumValueL1 L1 EnumValueL1
} }
EnumValueL1 struct { EnumValueL1 struct {
Options func() pref.ProtoMessage Options func() protoreflect.ProtoMessage
Number pref.EnumNumber Number protoreflect.EnumNumber
} }
) )
func (ed *Enum) Options() pref.ProtoMessage { func (ed *Enum) Options() protoreflect.ProtoMessage {
if f := ed.lazyInit().Options; f != nil { if f := ed.lazyInit().Options; f != nil {
return f() return f()
} }
return descopts.Enum return descopts.Enum
} }
func (ed *Enum) Values() pref.EnumValueDescriptors { func (ed *Enum) Values() protoreflect.EnumValueDescriptors {
if ed.L1.eagerValues { if ed.L1.eagerValues {
return &ed.L2.Values return &ed.L2.Values
} }
return &ed.lazyInit().Values return &ed.lazyInit().Values
} }
func (ed *Enum) ReservedNames() pref.Names { return &ed.lazyInit().ReservedNames } func (ed *Enum) ReservedNames() protoreflect.Names { return &ed.lazyInit().ReservedNames }
func (ed *Enum) ReservedRanges() pref.EnumRanges { return &ed.lazyInit().ReservedRanges } func (ed *Enum) ReservedRanges() protoreflect.EnumRanges { return &ed.lazyInit().ReservedRanges }
func (ed *Enum) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, ed) } func (ed *Enum) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, ed) }
func (ed *Enum) ProtoType(pref.EnumDescriptor) {} func (ed *Enum) ProtoType(protoreflect.EnumDescriptor) {}
func (ed *Enum) lazyInit() *EnumL2 { func (ed *Enum) lazyInit() *EnumL2 {
ed.L0.ParentFile.lazyInit() // implicitly initializes L2 ed.L0.ParentFile.lazyInit() // implicitly initializes L2
return ed.L2 return ed.L2
} }
func (ed *EnumValue) Options() pref.ProtoMessage { func (ed *EnumValue) Options() protoreflect.ProtoMessage {
if f := ed.L1.Options; f != nil { if f := ed.L1.Options; f != nil {
return f() return f()
} }
return descopts.EnumValue return descopts.EnumValue
} }
func (ed *EnumValue) Number() pref.EnumNumber { return ed.L1.Number } func (ed *EnumValue) Number() protoreflect.EnumNumber { return ed.L1.Number }
func (ed *EnumValue) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, ed) } func (ed *EnumValue) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, ed) }
func (ed *EnumValue) ProtoType(pref.EnumValueDescriptor) {} func (ed *EnumValue) ProtoType(protoreflect.EnumValueDescriptor) {}
type ( type (
Message struct { Message struct {
@ -180,14 +180,14 @@ type (
IsMessageSet bool // promoted from google.protobuf.MessageOptions IsMessageSet bool // promoted from google.protobuf.MessageOptions
} }
MessageL2 struct { MessageL2 struct {
Options func() pref.ProtoMessage Options func() protoreflect.ProtoMessage
Fields Fields Fields Fields
Oneofs Oneofs Oneofs Oneofs
ReservedNames Names ReservedNames Names
ReservedRanges FieldRanges ReservedRanges FieldRanges
RequiredNumbers FieldNumbers // must be consistent with Fields.Cardinality RequiredNumbers FieldNumbers // must be consistent with Fields.Cardinality
ExtensionRanges FieldRanges ExtensionRanges FieldRanges
ExtensionRangeOptions []func() pref.ProtoMessage // must be same length as ExtensionRanges ExtensionRangeOptions []func() protoreflect.ProtoMessage // must be same length as ExtensionRanges
} }
Field struct { Field struct {
@ -195,10 +195,10 @@ type (
L1 FieldL1 L1 FieldL1
} }
FieldL1 struct { FieldL1 struct {
Options func() pref.ProtoMessage Options func() protoreflect.ProtoMessage
Number pref.FieldNumber Number protoreflect.FieldNumber
Cardinality pref.Cardinality // must be consistent with Message.RequiredNumbers Cardinality protoreflect.Cardinality // must be consistent with Message.RequiredNumbers
Kind pref.Kind Kind protoreflect.Kind
StringName stringName StringName stringName
IsProto3Optional bool // promoted from google.protobuf.FieldDescriptorProto IsProto3Optional bool // promoted from google.protobuf.FieldDescriptorProto
IsWeak bool // promoted from google.protobuf.FieldOptions IsWeak bool // promoted from google.protobuf.FieldOptions
@ -207,9 +207,9 @@ type (
HasEnforceUTF8 bool // promoted from google.protobuf.FieldOptions HasEnforceUTF8 bool // promoted from google.protobuf.FieldOptions
EnforceUTF8 bool // promoted from google.protobuf.FieldOptions EnforceUTF8 bool // promoted from google.protobuf.FieldOptions
Default defaultValue Default defaultValue
ContainingOneof pref.OneofDescriptor // must be consistent with Message.Oneofs.Fields ContainingOneof protoreflect.OneofDescriptor // must be consistent with Message.Oneofs.Fields
Enum pref.EnumDescriptor Enum protoreflect.EnumDescriptor
Message pref.MessageDescriptor Message protoreflect.MessageDescriptor
} }
Oneof struct { Oneof struct {
@ -217,34 +217,34 @@ type (
L1 OneofL1 L1 OneofL1
} }
OneofL1 struct { OneofL1 struct {
Options func() pref.ProtoMessage Options func() protoreflect.ProtoMessage
Fields OneofFields // must be consistent with Message.Fields.ContainingOneof Fields OneofFields // must be consistent with Message.Fields.ContainingOneof
} }
) )
func (md *Message) Options() pref.ProtoMessage { func (md *Message) Options() protoreflect.ProtoMessage {
if f := md.lazyInit().Options; f != nil { if f := md.lazyInit().Options; f != nil {
return f() return f()
} }
return descopts.Message return descopts.Message
} }
func (md *Message) IsMapEntry() bool { return md.L1.IsMapEntry } func (md *Message) IsMapEntry() bool { return md.L1.IsMapEntry }
func (md *Message) Fields() pref.FieldDescriptors { return &md.lazyInit().Fields } func (md *Message) Fields() protoreflect.FieldDescriptors { return &md.lazyInit().Fields }
func (md *Message) Oneofs() pref.OneofDescriptors { return &md.lazyInit().Oneofs } func (md *Message) Oneofs() protoreflect.OneofDescriptors { return &md.lazyInit().Oneofs }
func (md *Message) ReservedNames() pref.Names { return &md.lazyInit().ReservedNames } func (md *Message) ReservedNames() protoreflect.Names { return &md.lazyInit().ReservedNames }
func (md *Message) ReservedRanges() pref.FieldRanges { return &md.lazyInit().ReservedRanges } func (md *Message) ReservedRanges() protoreflect.FieldRanges { return &md.lazyInit().ReservedRanges }
func (md *Message) RequiredNumbers() pref.FieldNumbers { return &md.lazyInit().RequiredNumbers } func (md *Message) RequiredNumbers() protoreflect.FieldNumbers { return &md.lazyInit().RequiredNumbers }
func (md *Message) ExtensionRanges() pref.FieldRanges { return &md.lazyInit().ExtensionRanges } func (md *Message) ExtensionRanges() protoreflect.FieldRanges { return &md.lazyInit().ExtensionRanges }
func (md *Message) ExtensionRangeOptions(i int) pref.ProtoMessage { func (md *Message) ExtensionRangeOptions(i int) protoreflect.ProtoMessage {
if f := md.lazyInit().ExtensionRangeOptions[i]; f != nil { if f := md.lazyInit().ExtensionRangeOptions[i]; f != nil {
return f() return f()
} }
return descopts.ExtensionRange return descopts.ExtensionRange
} }
func (md *Message) Enums() pref.EnumDescriptors { return &md.L1.Enums } func (md *Message) Enums() protoreflect.EnumDescriptors { return &md.L1.Enums }
func (md *Message) Messages() pref.MessageDescriptors { return &md.L1.Messages } func (md *Message) Messages() protoreflect.MessageDescriptors { return &md.L1.Messages }
func (md *Message) Extensions() pref.ExtensionDescriptors { return &md.L1.Extensions } func (md *Message) Extensions() protoreflect.ExtensionDescriptors { return &md.L1.Extensions }
func (md *Message) ProtoType(pref.MessageDescriptor) {} func (md *Message) ProtoType(protoreflect.MessageDescriptor) {}
func (md *Message) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, md) } func (md *Message) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, md) }
func (md *Message) lazyInit() *MessageL2 { func (md *Message) lazyInit() *MessageL2 {
md.L0.ParentFile.lazyInit() // implicitly initializes L2 md.L0.ParentFile.lazyInit() // implicitly initializes L2
@ -260,28 +260,28 @@ func (md *Message) IsMessageSet() bool {
return md.L1.IsMessageSet return md.L1.IsMessageSet
} }
func (fd *Field) Options() pref.ProtoMessage { func (fd *Field) Options() protoreflect.ProtoMessage {
if f := fd.L1.Options; f != nil { if f := fd.L1.Options; f != nil {
return f() return f()
} }
return descopts.Field return descopts.Field
} }
func (fd *Field) Number() pref.FieldNumber { return fd.L1.Number } func (fd *Field) Number() protoreflect.FieldNumber { return fd.L1.Number }
func (fd *Field) Cardinality() pref.Cardinality { return fd.L1.Cardinality } func (fd *Field) Cardinality() protoreflect.Cardinality { return fd.L1.Cardinality }
func (fd *Field) Kind() pref.Kind { return fd.L1.Kind } func (fd *Field) Kind() protoreflect.Kind { return fd.L1.Kind }
func (fd *Field) HasJSONName() bool { return fd.L1.StringName.hasJSON } func (fd *Field) HasJSONName() bool { return fd.L1.StringName.hasJSON }
func (fd *Field) JSONName() string { return fd.L1.StringName.getJSON(fd) } func (fd *Field) JSONName() string { return fd.L1.StringName.getJSON(fd) }
func (fd *Field) TextName() string { return fd.L1.StringName.getText(fd) } func (fd *Field) TextName() string { return fd.L1.StringName.getText(fd) }
func (fd *Field) HasPresence() bool { func (fd *Field) HasPresence() bool {
return fd.L1.Cardinality != pref.Repeated && (fd.L0.ParentFile.L1.Syntax == pref.Proto2 || fd.L1.Message != nil || fd.L1.ContainingOneof != nil) return fd.L1.Cardinality != protoreflect.Repeated && (fd.L0.ParentFile.L1.Syntax == protoreflect.Proto2 || fd.L1.Message != nil || fd.L1.ContainingOneof != nil)
} }
func (fd *Field) HasOptionalKeyword() bool { func (fd *Field) HasOptionalKeyword() bool {
return (fd.L0.ParentFile.L1.Syntax == pref.Proto2 && fd.L1.Cardinality == pref.Optional && fd.L1.ContainingOneof == nil) || fd.L1.IsProto3Optional return (fd.L0.ParentFile.L1.Syntax == protoreflect.Proto2 && fd.L1.Cardinality == protoreflect.Optional && fd.L1.ContainingOneof == nil) || fd.L1.IsProto3Optional
} }
func (fd *Field) IsPacked() bool { func (fd *Field) IsPacked() bool {
if !fd.L1.HasPacked && fd.L0.ParentFile.L1.Syntax != pref.Proto2 && fd.L1.Cardinality == pref.Repeated { if !fd.L1.HasPacked && fd.L0.ParentFile.L1.Syntax != protoreflect.Proto2 && fd.L1.Cardinality == protoreflect.Repeated {
switch fd.L1.Kind { switch fd.L1.Kind {
case pref.StringKind, pref.BytesKind, pref.MessageKind, pref.GroupKind: case protoreflect.StringKind, protoreflect.BytesKind, protoreflect.MessageKind, protoreflect.GroupKind:
default: default:
return true return true
} }
@ -290,40 +290,40 @@ func (fd *Field) IsPacked() bool {
} }
func (fd *Field) IsExtension() bool { return false } func (fd *Field) IsExtension() bool { return false }
func (fd *Field) IsWeak() bool { return fd.L1.IsWeak } func (fd *Field) IsWeak() bool { return fd.L1.IsWeak }
func (fd *Field) IsList() bool { return fd.Cardinality() == pref.Repeated && !fd.IsMap() } func (fd *Field) IsList() bool { return fd.Cardinality() == protoreflect.Repeated && !fd.IsMap() }
func (fd *Field) IsMap() bool { return fd.Message() != nil && fd.Message().IsMapEntry() } func (fd *Field) IsMap() bool { return fd.Message() != nil && fd.Message().IsMapEntry() }
func (fd *Field) MapKey() pref.FieldDescriptor { func (fd *Field) MapKey() protoreflect.FieldDescriptor {
if !fd.IsMap() { if !fd.IsMap() {
return nil return nil
} }
return fd.Message().Fields().ByNumber(genid.MapEntry_Key_field_number) return fd.Message().Fields().ByNumber(genid.MapEntry_Key_field_number)
} }
func (fd *Field) MapValue() pref.FieldDescriptor { func (fd *Field) MapValue() protoreflect.FieldDescriptor {
if !fd.IsMap() { if !fd.IsMap() {
return nil return nil
} }
return fd.Message().Fields().ByNumber(genid.MapEntry_Value_field_number) return fd.Message().Fields().ByNumber(genid.MapEntry_Value_field_number)
} }
func (fd *Field) HasDefault() bool { return fd.L1.Default.has } func (fd *Field) HasDefault() bool { return fd.L1.Default.has }
func (fd *Field) Default() pref.Value { return fd.L1.Default.get(fd) } func (fd *Field) Default() protoreflect.Value { return fd.L1.Default.get(fd) }
func (fd *Field) DefaultEnumValue() pref.EnumValueDescriptor { return fd.L1.Default.enum } func (fd *Field) DefaultEnumValue() protoreflect.EnumValueDescriptor { return fd.L1.Default.enum }
func (fd *Field) ContainingOneof() pref.OneofDescriptor { return fd.L1.ContainingOneof } func (fd *Field) ContainingOneof() protoreflect.OneofDescriptor { return fd.L1.ContainingOneof }
func (fd *Field) ContainingMessage() pref.MessageDescriptor { func (fd *Field) ContainingMessage() protoreflect.MessageDescriptor {
return fd.L0.Parent.(pref.MessageDescriptor) return fd.L0.Parent.(protoreflect.MessageDescriptor)
} }
func (fd *Field) Enum() pref.EnumDescriptor { func (fd *Field) Enum() protoreflect.EnumDescriptor {
return fd.L1.Enum return fd.L1.Enum
} }
func (fd *Field) Message() pref.MessageDescriptor { func (fd *Field) Message() protoreflect.MessageDescriptor {
if fd.L1.IsWeak { if fd.L1.IsWeak {
if d, _ := protoregistry.GlobalFiles.FindDescriptorByName(fd.L1.Message.FullName()); d != nil { if d, _ := protoregistry.GlobalFiles.FindDescriptorByName(fd.L1.Message.FullName()); d != nil {
return d.(pref.MessageDescriptor) return d.(protoreflect.MessageDescriptor)
} }
} }
return fd.L1.Message return fd.L1.Message
} }
func (fd *Field) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, fd) } func (fd *Field) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, fd) }
func (fd *Field) ProtoType(pref.FieldDescriptor) {} func (fd *Field) ProtoType(protoreflect.FieldDescriptor) {}
// EnforceUTF8 is a pseudo-internal API to determine whether to enforce UTF-8 // EnforceUTF8 is a pseudo-internal API to determine whether to enforce UTF-8
// validation for the string field. This exists for Google-internal use only // validation for the string field. This exists for Google-internal use only
@ -336,21 +336,21 @@ func (fd *Field) EnforceUTF8() bool {
if fd.L1.HasEnforceUTF8 { if fd.L1.HasEnforceUTF8 {
return fd.L1.EnforceUTF8 return fd.L1.EnforceUTF8
} }
return fd.L0.ParentFile.L1.Syntax == pref.Proto3 return fd.L0.ParentFile.L1.Syntax == protoreflect.Proto3
} }
func (od *Oneof) IsSynthetic() bool { func (od *Oneof) IsSynthetic() bool {
return od.L0.ParentFile.L1.Syntax == pref.Proto3 && len(od.L1.Fields.List) == 1 && od.L1.Fields.List[0].HasOptionalKeyword() return od.L0.ParentFile.L1.Syntax == protoreflect.Proto3 && len(od.L1.Fields.List) == 1 && od.L1.Fields.List[0].HasOptionalKeyword()
} }
func (od *Oneof) Options() pref.ProtoMessage { func (od *Oneof) Options() protoreflect.ProtoMessage {
if f := od.L1.Options; f != nil { if f := od.L1.Options; f != nil {
return f() return f()
} }
return descopts.Oneof return descopts.Oneof
} }
func (od *Oneof) Fields() pref.FieldDescriptors { return &od.L1.Fields } func (od *Oneof) Fields() protoreflect.FieldDescriptors { return &od.L1.Fields }
func (od *Oneof) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, od) } func (od *Oneof) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, od) }
func (od *Oneof) ProtoType(pref.OneofDescriptor) {} func (od *Oneof) ProtoType(protoreflect.OneofDescriptor) {}
type ( type (
Extension struct { Extension struct {
@ -359,54 +359,56 @@ type (
L2 *ExtensionL2 // protected by fileDesc.once L2 *ExtensionL2 // protected by fileDesc.once
} }
ExtensionL1 struct { ExtensionL1 struct {
Number pref.FieldNumber Number protoreflect.FieldNumber
Extendee pref.MessageDescriptor Extendee protoreflect.MessageDescriptor
Cardinality pref.Cardinality Cardinality protoreflect.Cardinality
Kind pref.Kind Kind protoreflect.Kind
} }
ExtensionL2 struct { ExtensionL2 struct {
Options func() pref.ProtoMessage Options func() protoreflect.ProtoMessage
StringName stringName StringName stringName
IsProto3Optional bool // promoted from google.protobuf.FieldDescriptorProto IsProto3Optional bool // promoted from google.protobuf.FieldDescriptorProto
IsPacked bool // promoted from google.protobuf.FieldOptions IsPacked bool // promoted from google.protobuf.FieldOptions
Default defaultValue Default defaultValue
Enum pref.EnumDescriptor Enum protoreflect.EnumDescriptor
Message pref.MessageDescriptor Message protoreflect.MessageDescriptor
} }
) )
func (xd *Extension) Options() pref.ProtoMessage { func (xd *Extension) Options() protoreflect.ProtoMessage {
if f := xd.lazyInit().Options; f != nil { if f := xd.lazyInit().Options; f != nil {
return f() return f()
} }
return descopts.Field return descopts.Field
} }
func (xd *Extension) Number() pref.FieldNumber { return xd.L1.Number } func (xd *Extension) Number() protoreflect.FieldNumber { return xd.L1.Number }
func (xd *Extension) Cardinality() pref.Cardinality { return xd.L1.Cardinality } func (xd *Extension) Cardinality() protoreflect.Cardinality { return xd.L1.Cardinality }
func (xd *Extension) Kind() pref.Kind { return xd.L1.Kind } func (xd *Extension) Kind() protoreflect.Kind { return xd.L1.Kind }
func (xd *Extension) HasJSONName() bool { return xd.lazyInit().StringName.hasJSON } func (xd *Extension) HasJSONName() bool { return xd.lazyInit().StringName.hasJSON }
func (xd *Extension) JSONName() string { return xd.lazyInit().StringName.getJSON(xd) } func (xd *Extension) JSONName() string { return xd.lazyInit().StringName.getJSON(xd) }
func (xd *Extension) TextName() string { return xd.lazyInit().StringName.getText(xd) } func (xd *Extension) TextName() string { return xd.lazyInit().StringName.getText(xd) }
func (xd *Extension) HasPresence() bool { return xd.L1.Cardinality != pref.Repeated } func (xd *Extension) HasPresence() bool { return xd.L1.Cardinality != protoreflect.Repeated }
func (xd *Extension) HasOptionalKeyword() bool { func (xd *Extension) HasOptionalKeyword() bool {
return (xd.L0.ParentFile.L1.Syntax == pref.Proto2 && xd.L1.Cardinality == pref.Optional) || xd.lazyInit().IsProto3Optional return (xd.L0.ParentFile.L1.Syntax == protoreflect.Proto2 && xd.L1.Cardinality == protoreflect.Optional) || xd.lazyInit().IsProto3Optional
} }
func (xd *Extension) IsPacked() bool { return xd.lazyInit().IsPacked } func (xd *Extension) IsPacked() bool { return xd.lazyInit().IsPacked }
func (xd *Extension) IsExtension() bool { return true } func (xd *Extension) IsExtension() bool { return true }
func (xd *Extension) IsWeak() bool { return false } func (xd *Extension) IsWeak() bool { return false }
func (xd *Extension) IsList() bool { return xd.Cardinality() == pref.Repeated } func (xd *Extension) IsList() bool { return xd.Cardinality() == protoreflect.Repeated }
func (xd *Extension) IsMap() bool { return false } func (xd *Extension) IsMap() bool { return false }
func (xd *Extension) MapKey() pref.FieldDescriptor { return nil } func (xd *Extension) MapKey() protoreflect.FieldDescriptor { return nil }
func (xd *Extension) MapValue() pref.FieldDescriptor { return nil } func (xd *Extension) MapValue() protoreflect.FieldDescriptor { return nil }
func (xd *Extension) HasDefault() bool { return xd.lazyInit().Default.has } func (xd *Extension) HasDefault() bool { return xd.lazyInit().Default.has }
func (xd *Extension) Default() pref.Value { return xd.lazyInit().Default.get(xd) } func (xd *Extension) Default() protoreflect.Value { return xd.lazyInit().Default.get(xd) }
func (xd *Extension) DefaultEnumValue() pref.EnumValueDescriptor { return xd.lazyInit().Default.enum } func (xd *Extension) DefaultEnumValue() protoreflect.EnumValueDescriptor {
func (xd *Extension) ContainingOneof() pref.OneofDescriptor { return nil } return xd.lazyInit().Default.enum
func (xd *Extension) ContainingMessage() pref.MessageDescriptor { return xd.L1.Extendee } }
func (xd *Extension) Enum() pref.EnumDescriptor { return xd.lazyInit().Enum } func (xd *Extension) ContainingOneof() protoreflect.OneofDescriptor { return nil }
func (xd *Extension) Message() pref.MessageDescriptor { return xd.lazyInit().Message } func (xd *Extension) ContainingMessage() protoreflect.MessageDescriptor { return xd.L1.Extendee }
func (xd *Extension) Enum() protoreflect.EnumDescriptor { return xd.lazyInit().Enum }
func (xd *Extension) Message() protoreflect.MessageDescriptor { return xd.lazyInit().Message }
func (xd *Extension) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, xd) } func (xd *Extension) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, xd) }
func (xd *Extension) ProtoType(pref.FieldDescriptor) {} func (xd *Extension) ProtoType(protoreflect.FieldDescriptor) {}
func (xd *Extension) ProtoInternal(pragma.DoNotImplement) {} func (xd *Extension) ProtoInternal(pragma.DoNotImplement) {}
func (xd *Extension) lazyInit() *ExtensionL2 { func (xd *Extension) lazyInit() *ExtensionL2 {
xd.L0.ParentFile.lazyInit() // implicitly initializes L2 xd.L0.ParentFile.lazyInit() // implicitly initializes L2
@ -421,7 +423,7 @@ type (
} }
ServiceL1 struct{} ServiceL1 struct{}
ServiceL2 struct { ServiceL2 struct {
Options func() pref.ProtoMessage Options func() protoreflect.ProtoMessage
Methods Methods Methods Methods
} }
@ -430,48 +432,48 @@ type (
L1 MethodL1 L1 MethodL1
} }
MethodL1 struct { MethodL1 struct {
Options func() pref.ProtoMessage Options func() protoreflect.ProtoMessage
Input pref.MessageDescriptor Input protoreflect.MessageDescriptor
Output pref.MessageDescriptor Output protoreflect.MessageDescriptor
IsStreamingClient bool IsStreamingClient bool
IsStreamingServer bool IsStreamingServer bool
} }
) )
func (sd *Service) Options() pref.ProtoMessage { func (sd *Service) Options() protoreflect.ProtoMessage {
if f := sd.lazyInit().Options; f != nil { if f := sd.lazyInit().Options; f != nil {
return f() return f()
} }
return descopts.Service return descopts.Service
} }
func (sd *Service) Methods() pref.MethodDescriptors { return &sd.lazyInit().Methods } func (sd *Service) Methods() protoreflect.MethodDescriptors { return &sd.lazyInit().Methods }
func (sd *Service) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, sd) } func (sd *Service) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, sd) }
func (sd *Service) ProtoType(pref.ServiceDescriptor) {} func (sd *Service) ProtoType(protoreflect.ServiceDescriptor) {}
func (sd *Service) ProtoInternal(pragma.DoNotImplement) {} func (sd *Service) ProtoInternal(pragma.DoNotImplement) {}
func (sd *Service) lazyInit() *ServiceL2 { func (sd *Service) lazyInit() *ServiceL2 {
sd.L0.ParentFile.lazyInit() // implicitly initializes L2 sd.L0.ParentFile.lazyInit() // implicitly initializes L2
return sd.L2 return sd.L2
} }
func (md *Method) Options() pref.ProtoMessage { func (md *Method) Options() protoreflect.ProtoMessage {
if f := md.L1.Options; f != nil { if f := md.L1.Options; f != nil {
return f() return f()
} }
return descopts.Method return descopts.Method
} }
func (md *Method) Input() pref.MessageDescriptor { return md.L1.Input } func (md *Method) Input() protoreflect.MessageDescriptor { return md.L1.Input }
func (md *Method) Output() pref.MessageDescriptor { return md.L1.Output } func (md *Method) Output() protoreflect.MessageDescriptor { return md.L1.Output }
func (md *Method) IsStreamingClient() bool { return md.L1.IsStreamingClient } func (md *Method) IsStreamingClient() bool { return md.L1.IsStreamingClient }
func (md *Method) IsStreamingServer() bool { return md.L1.IsStreamingServer } func (md *Method) IsStreamingServer() bool { return md.L1.IsStreamingServer }
func (md *Method) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, md) } func (md *Method) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, md) }
func (md *Method) ProtoType(pref.MethodDescriptor) {} func (md *Method) ProtoType(protoreflect.MethodDescriptor) {}
func (md *Method) ProtoInternal(pragma.DoNotImplement) {} func (md *Method) ProtoInternal(pragma.DoNotImplement) {}
// Surrogate files are can be used to create standalone descriptors // Surrogate files are can be used to create standalone descriptors
// where the syntax is only information derived from the parent file. // where the syntax is only information derived from the parent file.
var ( var (
SurrogateProto2 = &File{L1: FileL1{Syntax: pref.Proto2}, L2: &FileL2{}} SurrogateProto2 = &File{L1: FileL1{Syntax: protoreflect.Proto2}, L2: &FileL2{}}
SurrogateProto3 = &File{L1: FileL1{Syntax: pref.Proto3}, L2: &FileL2{}} SurrogateProto3 = &File{L1: FileL1{Syntax: protoreflect.Proto3}, L2: &FileL2{}}
) )
type ( type (
@ -479,24 +481,24 @@ type (
L0 BaseL0 L0 BaseL0
} }
BaseL0 struct { BaseL0 struct {
FullName pref.FullName // must be populated FullName protoreflect.FullName // must be populated
ParentFile *File // must be populated ParentFile *File // must be populated
Parent pref.Descriptor Parent protoreflect.Descriptor
Index int Index int
} }
) )
func (d *Base) Name() pref.Name { return d.L0.FullName.Name() } func (d *Base) Name() protoreflect.Name { return d.L0.FullName.Name() }
func (d *Base) FullName() pref.FullName { return d.L0.FullName } func (d *Base) FullName() protoreflect.FullName { return d.L0.FullName }
func (d *Base) ParentFile() pref.FileDescriptor { func (d *Base) ParentFile() protoreflect.FileDescriptor {
if d.L0.ParentFile == SurrogateProto2 || d.L0.ParentFile == SurrogateProto3 { if d.L0.ParentFile == SurrogateProto2 || d.L0.ParentFile == SurrogateProto3 {
return nil // surrogate files are not real parents return nil // surrogate files are not real parents
} }
return d.L0.ParentFile return d.L0.ParentFile
} }
func (d *Base) Parent() pref.Descriptor { return d.L0.Parent } func (d *Base) Parent() protoreflect.Descriptor { return d.L0.Parent }
func (d *Base) Index() int { return d.L0.Index } func (d *Base) Index() int { return d.L0.Index }
func (d *Base) Syntax() pref.Syntax { return d.L0.ParentFile.Syntax() } func (d *Base) Syntax() protoreflect.Syntax { return d.L0.ParentFile.Syntax() }
func (d *Base) IsPlaceholder() bool { return false } func (d *Base) IsPlaceholder() bool { return false }
func (d *Base) ProtoInternal(pragma.DoNotImplement) {} func (d *Base) ProtoInternal(pragma.DoNotImplement) {}
@ -513,7 +515,7 @@ func (s *stringName) InitJSON(name string) {
s.nameJSON = name s.nameJSON = name
} }
func (s *stringName) lazyInit(fd pref.FieldDescriptor) *stringName { func (s *stringName) lazyInit(fd protoreflect.FieldDescriptor) *stringName {
s.once.Do(func() { s.once.Do(func() {
if fd.IsExtension() { if fd.IsExtension() {
// For extensions, JSON and text are formatted the same way. // For extensions, JSON and text are formatted the same way.
@ -533,7 +535,7 @@ func (s *stringName) lazyInit(fd pref.FieldDescriptor) *stringName {
// Format the text name. // Format the text name.
s.nameText = string(fd.Name()) s.nameText = string(fd.Name())
if fd.Kind() == pref.GroupKind { if fd.Kind() == protoreflect.GroupKind {
s.nameText = string(fd.Message().Name()) s.nameText = string(fd.Message().Name())
} }
} }
@ -541,10 +543,10 @@ func (s *stringName) lazyInit(fd pref.FieldDescriptor) *stringName {
return s return s
} }
func (s *stringName) getJSON(fd pref.FieldDescriptor) string { return s.lazyInit(fd).nameJSON } func (s *stringName) getJSON(fd protoreflect.FieldDescriptor) string { return s.lazyInit(fd).nameJSON }
func (s *stringName) getText(fd pref.FieldDescriptor) string { return s.lazyInit(fd).nameText } func (s *stringName) getText(fd protoreflect.FieldDescriptor) string { return s.lazyInit(fd).nameText }
func DefaultValue(v pref.Value, ev pref.EnumValueDescriptor) defaultValue { func DefaultValue(v protoreflect.Value, ev protoreflect.EnumValueDescriptor) defaultValue {
dv := defaultValue{has: v.IsValid(), val: v, enum: ev} dv := defaultValue{has: v.IsValid(), val: v, enum: ev}
if b, ok := v.Interface().([]byte); ok { if b, ok := v.Interface().([]byte); ok {
// Store a copy of the default bytes, so that we can detect // Store a copy of the default bytes, so that we can detect
@ -554,9 +556,9 @@ func DefaultValue(v pref.Value, ev pref.EnumValueDescriptor) defaultValue {
return dv return dv
} }
func unmarshalDefault(b []byte, k pref.Kind, pf *File, ed pref.EnumDescriptor) defaultValue { func unmarshalDefault(b []byte, k protoreflect.Kind, pf *File, ed protoreflect.EnumDescriptor) defaultValue {
var evs pref.EnumValueDescriptors var evs protoreflect.EnumValueDescriptors
if k == pref.EnumKind { if k == protoreflect.EnumKind {
// If the enum is declared within the same file, be careful not to // If the enum is declared within the same file, be careful not to
// blindly call the Values method, lest we bind ourselves in a deadlock. // blindly call the Values method, lest we bind ourselves in a deadlock.
if e, ok := ed.(*Enum); ok && e.L0.ParentFile == pf { if e, ok := ed.(*Enum); ok && e.L0.ParentFile == pf {
@ -567,9 +569,9 @@ func unmarshalDefault(b []byte, k pref.Kind, pf *File, ed pref.EnumDescriptor) d
// If we are unable to resolve the enum dependency, use a placeholder // If we are unable to resolve the enum dependency, use a placeholder
// enum value since we will not be able to parse the default value. // enum value since we will not be able to parse the default value.
if ed.IsPlaceholder() && pref.Name(b).IsValid() { if ed.IsPlaceholder() && protoreflect.Name(b).IsValid() {
v := pref.ValueOfEnum(0) v := protoreflect.ValueOfEnum(0)
ev := PlaceholderEnumValue(ed.FullName().Parent().Append(pref.Name(b))) ev := PlaceholderEnumValue(ed.FullName().Parent().Append(protoreflect.Name(b)))
return DefaultValue(v, ev) return DefaultValue(v, ev)
} }
} }
@ -583,41 +585,41 @@ func unmarshalDefault(b []byte, k pref.Kind, pf *File, ed pref.EnumDescriptor) d
type defaultValue struct { type defaultValue struct {
has bool has bool
val pref.Value val protoreflect.Value
enum pref.EnumValueDescriptor enum protoreflect.EnumValueDescriptor
bytes []byte bytes []byte
} }
func (dv *defaultValue) get(fd pref.FieldDescriptor) pref.Value { func (dv *defaultValue) get(fd protoreflect.FieldDescriptor) protoreflect.Value {
// Return the zero value as the default if unpopulated. // Return the zero value as the default if unpopulated.
if !dv.has { if !dv.has {
if fd.Cardinality() == pref.Repeated { if fd.Cardinality() == protoreflect.Repeated {
return pref.Value{} return protoreflect.Value{}
} }
switch fd.Kind() { switch fd.Kind() {
case pref.BoolKind: case protoreflect.BoolKind:
return pref.ValueOfBool(false) return protoreflect.ValueOfBool(false)
case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind: case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
return pref.ValueOfInt32(0) return protoreflect.ValueOfInt32(0)
case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind: case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
return pref.ValueOfInt64(0) return protoreflect.ValueOfInt64(0)
case pref.Uint32Kind, pref.Fixed32Kind: case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
return pref.ValueOfUint32(0) return protoreflect.ValueOfUint32(0)
case pref.Uint64Kind, pref.Fixed64Kind: case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
return pref.ValueOfUint64(0) return protoreflect.ValueOfUint64(0)
case pref.FloatKind: case protoreflect.FloatKind:
return pref.ValueOfFloat32(0) return protoreflect.ValueOfFloat32(0)
case pref.DoubleKind: case protoreflect.DoubleKind:
return pref.ValueOfFloat64(0) return protoreflect.ValueOfFloat64(0)
case pref.StringKind: case protoreflect.StringKind:
return pref.ValueOfString("") return protoreflect.ValueOfString("")
case pref.BytesKind: case protoreflect.BytesKind:
return pref.ValueOfBytes(nil) return protoreflect.ValueOfBytes(nil)
case pref.EnumKind: case protoreflect.EnumKind:
if evs := fd.Enum().Values(); evs.Len() > 0 { if evs := fd.Enum().Values(); evs.Len() > 0 {
return pref.ValueOfEnum(evs.Get(0).Number()) return protoreflect.ValueOfEnum(evs.Get(0).Number())
} }
return pref.ValueOfEnum(0) return protoreflect.ValueOfEnum(0)
} }
} }

View File

@ -10,7 +10,7 @@ import (
"google.golang.org/protobuf/encoding/protowire" "google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/genid" "google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/internal/strs" "google.golang.org/protobuf/internal/strs"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
// fileRaw is a data struct used when initializing a file descriptor from // fileRaw is a data struct used when initializing a file descriptor from
@ -95,7 +95,7 @@ func (fd *File) unmarshalSeed(b []byte) {
sb := getBuilder() sb := getBuilder()
defer putBuilder(sb) defer putBuilder(sb)
var prevField pref.FieldNumber var prevField protoreflect.FieldNumber
var numEnums, numMessages, numExtensions, numServices int var numEnums, numMessages, numExtensions, numServices int
var posEnums, posMessages, posExtensions, posServices int var posEnums, posMessages, posExtensions, posServices int
b0 := b b0 := b
@ -110,16 +110,16 @@ func (fd *File) unmarshalSeed(b []byte) {
case genid.FileDescriptorProto_Syntax_field_number: case genid.FileDescriptorProto_Syntax_field_number:
switch string(v) { switch string(v) {
case "proto2": case "proto2":
fd.L1.Syntax = pref.Proto2 fd.L1.Syntax = protoreflect.Proto2
case "proto3": case "proto3":
fd.L1.Syntax = pref.Proto3 fd.L1.Syntax = protoreflect.Proto3
default: default:
panic("invalid syntax") panic("invalid syntax")
} }
case genid.FileDescriptorProto_Name_field_number: case genid.FileDescriptorProto_Name_field_number:
fd.L1.Path = sb.MakeString(v) fd.L1.Path = sb.MakeString(v)
case genid.FileDescriptorProto_Package_field_number: case genid.FileDescriptorProto_Package_field_number:
fd.L1.Package = pref.FullName(sb.MakeString(v)) fd.L1.Package = protoreflect.FullName(sb.MakeString(v))
case genid.FileDescriptorProto_EnumType_field_number: case genid.FileDescriptorProto_EnumType_field_number:
if prevField != genid.FileDescriptorProto_EnumType_field_number { if prevField != genid.FileDescriptorProto_EnumType_field_number {
if numEnums > 0 { if numEnums > 0 {
@ -163,7 +163,7 @@ func (fd *File) unmarshalSeed(b []byte) {
// If syntax is missing, it is assumed to be proto2. // If syntax is missing, it is assumed to be proto2.
if fd.L1.Syntax == 0 { if fd.L1.Syntax == 0 {
fd.L1.Syntax = pref.Proto2 fd.L1.Syntax = protoreflect.Proto2
} }
// Must allocate all declarations before parsing each descriptor type // Must allocate all declarations before parsing each descriptor type
@ -219,7 +219,7 @@ func (fd *File) unmarshalSeed(b []byte) {
} }
} }
func (ed *Enum) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) { func (ed *Enum) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
ed.L0.ParentFile = pf ed.L0.ParentFile = pf
ed.L0.Parent = pd ed.L0.Parent = pd
ed.L0.Index = i ed.L0.Index = i
@ -271,12 +271,12 @@ func (ed *Enum) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref.Desc
} }
} }
func (md *Message) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) { func (md *Message) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
md.L0.ParentFile = pf md.L0.ParentFile = pf
md.L0.Parent = pd md.L0.Parent = pd
md.L0.Index = i md.L0.Index = i
var prevField pref.FieldNumber var prevField protoreflect.FieldNumber
var numEnums, numMessages, numExtensions int var numEnums, numMessages, numExtensions int
var posEnums, posMessages, posExtensions int var posEnums, posMessages, posExtensions int
b0 := b b0 := b
@ -387,7 +387,7 @@ func (md *Message) unmarshalSeedOptions(b []byte) {
} }
} }
func (xd *Extension) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) { func (xd *Extension) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
xd.L0.ParentFile = pf xd.L0.ParentFile = pf
xd.L0.Parent = pd xd.L0.Parent = pd
xd.L0.Index = i xd.L0.Index = i
@ -401,11 +401,11 @@ func (xd *Extension) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref
b = b[m:] b = b[m:]
switch num { switch num {
case genid.FieldDescriptorProto_Number_field_number: case genid.FieldDescriptorProto_Number_field_number:
xd.L1.Number = pref.FieldNumber(v) xd.L1.Number = protoreflect.FieldNumber(v)
case genid.FieldDescriptorProto_Label_field_number: case genid.FieldDescriptorProto_Label_field_number:
xd.L1.Cardinality = pref.Cardinality(v) xd.L1.Cardinality = protoreflect.Cardinality(v)
case genid.FieldDescriptorProto_Type_field_number: case genid.FieldDescriptorProto_Type_field_number:
xd.L1.Kind = pref.Kind(v) xd.L1.Kind = protoreflect.Kind(v)
} }
case protowire.BytesType: case protowire.BytesType:
v, m := protowire.ConsumeBytes(b) v, m := protowire.ConsumeBytes(b)
@ -423,7 +423,7 @@ func (xd *Extension) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref
} }
} }
func (sd *Service) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) { func (sd *Service) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
sd.L0.ParentFile = pf sd.L0.ParentFile = pf
sd.L0.Parent = pd sd.L0.Parent = pd
sd.L0.Index = i sd.L0.Index = i
@ -459,13 +459,13 @@ func putBuilder(b *strs.Builder) {
// makeFullName converts b to a protoreflect.FullName, // makeFullName converts b to a protoreflect.FullName,
// where b must start with a leading dot. // where b must start with a leading dot.
func makeFullName(sb *strs.Builder, b []byte) pref.FullName { func makeFullName(sb *strs.Builder, b []byte) protoreflect.FullName {
if len(b) == 0 || b[0] != '.' { if len(b) == 0 || b[0] != '.' {
panic("name reference must be fully qualified") panic("name reference must be fully qualified")
} }
return pref.FullName(sb.MakeString(b[1:])) return protoreflect.FullName(sb.MakeString(b[1:]))
} }
func appendFullName(sb *strs.Builder, prefix pref.FullName, suffix []byte) pref.FullName { func appendFullName(sb *strs.Builder, prefix protoreflect.FullName, suffix []byte) protoreflect.FullName {
return sb.AppendFullName(prefix, pref.Name(strs.UnsafeString(suffix))) return sb.AppendFullName(prefix, protoreflect.Name(strs.UnsafeString(suffix)))
} }

View File

@ -13,7 +13,7 @@ import (
"google.golang.org/protobuf/internal/genid" "google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/internal/strs" "google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/proto" "google.golang.org/protobuf/proto"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
func (fd *File) lazyRawInit() { func (fd *File) lazyRawInit() {
@ -39,10 +39,10 @@ func (file *File) resolveMessages() {
// Resolve message field dependency. // Resolve message field dependency.
switch fd.L1.Kind { switch fd.L1.Kind {
case pref.EnumKind: case protoreflect.EnumKind:
fd.L1.Enum = file.resolveEnumDependency(fd.L1.Enum, listFieldDeps, depIdx) fd.L1.Enum = file.resolveEnumDependency(fd.L1.Enum, listFieldDeps, depIdx)
depIdx++ depIdx++
case pref.MessageKind, pref.GroupKind: case protoreflect.MessageKind, protoreflect.GroupKind:
fd.L1.Message = file.resolveMessageDependency(fd.L1.Message, listFieldDeps, depIdx) fd.L1.Message = file.resolveMessageDependency(fd.L1.Message, listFieldDeps, depIdx)
depIdx++ depIdx++
} }
@ -62,10 +62,10 @@ func (file *File) resolveExtensions() {
// Resolve extension field dependency. // Resolve extension field dependency.
switch xd.L1.Kind { switch xd.L1.Kind {
case pref.EnumKind: case protoreflect.EnumKind:
xd.L2.Enum = file.resolveEnumDependency(xd.L2.Enum, listExtDeps, depIdx) xd.L2.Enum = file.resolveEnumDependency(xd.L2.Enum, listExtDeps, depIdx)
depIdx++ depIdx++
case pref.MessageKind, pref.GroupKind: case protoreflect.MessageKind, protoreflect.GroupKind:
xd.L2.Message = file.resolveMessageDependency(xd.L2.Message, listExtDeps, depIdx) xd.L2.Message = file.resolveMessageDependency(xd.L2.Message, listExtDeps, depIdx)
depIdx++ depIdx++
} }
@ -92,7 +92,7 @@ func (file *File) resolveServices() {
} }
} }
func (file *File) resolveEnumDependency(ed pref.EnumDescriptor, i, j int32) pref.EnumDescriptor { func (file *File) resolveEnumDependency(ed protoreflect.EnumDescriptor, i, j int32) protoreflect.EnumDescriptor {
r := file.builder.FileRegistry r := file.builder.FileRegistry
if r, ok := r.(resolverByIndex); ok { if r, ok := r.(resolverByIndex); ok {
if ed2 := r.FindEnumByIndex(i, j, file.allEnums, file.allMessages); ed2 != nil { if ed2 := r.FindEnumByIndex(i, j, file.allEnums, file.allMessages); ed2 != nil {
@ -105,12 +105,12 @@ func (file *File) resolveEnumDependency(ed pref.EnumDescriptor, i, j int32) pref
} }
} }
if d, _ := r.FindDescriptorByName(ed.FullName()); d != nil { if d, _ := r.FindDescriptorByName(ed.FullName()); d != nil {
return d.(pref.EnumDescriptor) return d.(protoreflect.EnumDescriptor)
} }
return ed return ed
} }
func (file *File) resolveMessageDependency(md pref.MessageDescriptor, i, j int32) pref.MessageDescriptor { func (file *File) resolveMessageDependency(md protoreflect.MessageDescriptor, i, j int32) protoreflect.MessageDescriptor {
r := file.builder.FileRegistry r := file.builder.FileRegistry
if r, ok := r.(resolverByIndex); ok { if r, ok := r.(resolverByIndex); ok {
if md2 := r.FindMessageByIndex(i, j, file.allEnums, file.allMessages); md2 != nil { if md2 := r.FindMessageByIndex(i, j, file.allEnums, file.allMessages); md2 != nil {
@ -123,7 +123,7 @@ func (file *File) resolveMessageDependency(md pref.MessageDescriptor, i, j int32
} }
} }
if d, _ := r.FindDescriptorByName(md.FullName()); d != nil { if d, _ := r.FindDescriptorByName(md.FullName()); d != nil {
return d.(pref.MessageDescriptor) return d.(protoreflect.MessageDescriptor)
} }
return md return md
} }
@ -158,7 +158,7 @@ func (fd *File) unmarshalFull(b []byte) {
if imp == nil { if imp == nil {
imp = PlaceholderFile(path) imp = PlaceholderFile(path)
} }
fd.L2.Imports = append(fd.L2.Imports, pref.FileImport{FileDescriptor: imp}) fd.L2.Imports = append(fd.L2.Imports, protoreflect.FileImport{FileDescriptor: imp})
case genid.FileDescriptorProto_EnumType_field_number: case genid.FileDescriptorProto_EnumType_field_number:
fd.L1.Enums.List[enumIdx].unmarshalFull(v, sb) fd.L1.Enums.List[enumIdx].unmarshalFull(v, sb)
enumIdx++ enumIdx++
@ -199,7 +199,7 @@ func (ed *Enum) unmarshalFull(b []byte, sb *strs.Builder) {
case genid.EnumDescriptorProto_Value_field_number: case genid.EnumDescriptorProto_Value_field_number:
rawValues = append(rawValues, v) rawValues = append(rawValues, v)
case genid.EnumDescriptorProto_ReservedName_field_number: case genid.EnumDescriptorProto_ReservedName_field_number:
ed.L2.ReservedNames.List = append(ed.L2.ReservedNames.List, pref.Name(sb.MakeString(v))) ed.L2.ReservedNames.List = append(ed.L2.ReservedNames.List, protoreflect.Name(sb.MakeString(v)))
case genid.EnumDescriptorProto_ReservedRange_field_number: case genid.EnumDescriptorProto_ReservedRange_field_number:
ed.L2.ReservedRanges.List = append(ed.L2.ReservedRanges.List, unmarshalEnumReservedRange(v)) ed.L2.ReservedRanges.List = append(ed.L2.ReservedRanges.List, unmarshalEnumReservedRange(v))
case genid.EnumDescriptorProto_Options_field_number: case genid.EnumDescriptorProto_Options_field_number:
@ -219,7 +219,7 @@ func (ed *Enum) unmarshalFull(b []byte, sb *strs.Builder) {
ed.L2.Options = ed.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Enum, rawOptions) ed.L2.Options = ed.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Enum, rawOptions)
} }
func unmarshalEnumReservedRange(b []byte) (r [2]pref.EnumNumber) { func unmarshalEnumReservedRange(b []byte) (r [2]protoreflect.EnumNumber) {
for len(b) > 0 { for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b) num, typ, n := protowire.ConsumeTag(b)
b = b[n:] b = b[n:]
@ -229,9 +229,9 @@ func unmarshalEnumReservedRange(b []byte) (r [2]pref.EnumNumber) {
b = b[m:] b = b[m:]
switch num { switch num {
case genid.EnumDescriptorProto_EnumReservedRange_Start_field_number: case genid.EnumDescriptorProto_EnumReservedRange_Start_field_number:
r[0] = pref.EnumNumber(v) r[0] = protoreflect.EnumNumber(v)
case genid.EnumDescriptorProto_EnumReservedRange_End_field_number: case genid.EnumDescriptorProto_EnumReservedRange_End_field_number:
r[1] = pref.EnumNumber(v) r[1] = protoreflect.EnumNumber(v)
} }
default: default:
m := protowire.ConsumeFieldValue(num, typ, b) m := protowire.ConsumeFieldValue(num, typ, b)
@ -241,7 +241,7 @@ func unmarshalEnumReservedRange(b []byte) (r [2]pref.EnumNumber) {
return r return r
} }
func (vd *EnumValue) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) { func (vd *EnumValue) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
vd.L0.ParentFile = pf vd.L0.ParentFile = pf
vd.L0.Parent = pd vd.L0.Parent = pd
vd.L0.Index = i vd.L0.Index = i
@ -256,7 +256,7 @@ func (vd *EnumValue) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref
b = b[m:] b = b[m:]
switch num { switch num {
case genid.EnumValueDescriptorProto_Number_field_number: case genid.EnumValueDescriptorProto_Number_field_number:
vd.L1.Number = pref.EnumNumber(v) vd.L1.Number = protoreflect.EnumNumber(v)
} }
case protowire.BytesType: case protowire.BytesType:
v, m := protowire.ConsumeBytes(b) v, m := protowire.ConsumeBytes(b)
@ -294,7 +294,7 @@ func (md *Message) unmarshalFull(b []byte, sb *strs.Builder) {
case genid.DescriptorProto_OneofDecl_field_number: case genid.DescriptorProto_OneofDecl_field_number:
rawOneofs = append(rawOneofs, v) rawOneofs = append(rawOneofs, v)
case genid.DescriptorProto_ReservedName_field_number: case genid.DescriptorProto_ReservedName_field_number:
md.L2.ReservedNames.List = append(md.L2.ReservedNames.List, pref.Name(sb.MakeString(v))) md.L2.ReservedNames.List = append(md.L2.ReservedNames.List, protoreflect.Name(sb.MakeString(v)))
case genid.DescriptorProto_ReservedRange_field_number: case genid.DescriptorProto_ReservedRange_field_number:
md.L2.ReservedRanges.List = append(md.L2.ReservedRanges.List, unmarshalMessageReservedRange(v)) md.L2.ReservedRanges.List = append(md.L2.ReservedRanges.List, unmarshalMessageReservedRange(v))
case genid.DescriptorProto_ExtensionRange_field_number: case genid.DescriptorProto_ExtensionRange_field_number:
@ -326,7 +326,7 @@ func (md *Message) unmarshalFull(b []byte, sb *strs.Builder) {
for i, b := range rawFields { for i, b := range rawFields {
fd := &md.L2.Fields.List[i] fd := &md.L2.Fields.List[i]
fd.unmarshalFull(b, sb, md.L0.ParentFile, md, i) fd.unmarshalFull(b, sb, md.L0.ParentFile, md, i)
if fd.L1.Cardinality == pref.Required { if fd.L1.Cardinality == protoreflect.Required {
md.L2.RequiredNumbers.List = append(md.L2.RequiredNumbers.List, fd.L1.Number) md.L2.RequiredNumbers.List = append(md.L2.RequiredNumbers.List, fd.L1.Number)
} }
} }
@ -359,7 +359,7 @@ func (md *Message) unmarshalOptions(b []byte) {
} }
} }
func unmarshalMessageReservedRange(b []byte) (r [2]pref.FieldNumber) { func unmarshalMessageReservedRange(b []byte) (r [2]protoreflect.FieldNumber) {
for len(b) > 0 { for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b) num, typ, n := protowire.ConsumeTag(b)
b = b[n:] b = b[n:]
@ -369,9 +369,9 @@ func unmarshalMessageReservedRange(b []byte) (r [2]pref.FieldNumber) {
b = b[m:] b = b[m:]
switch num { switch num {
case genid.DescriptorProto_ReservedRange_Start_field_number: case genid.DescriptorProto_ReservedRange_Start_field_number:
r[0] = pref.FieldNumber(v) r[0] = protoreflect.FieldNumber(v)
case genid.DescriptorProto_ReservedRange_End_field_number: case genid.DescriptorProto_ReservedRange_End_field_number:
r[1] = pref.FieldNumber(v) r[1] = protoreflect.FieldNumber(v)
} }
default: default:
m := protowire.ConsumeFieldValue(num, typ, b) m := protowire.ConsumeFieldValue(num, typ, b)
@ -381,7 +381,7 @@ func unmarshalMessageReservedRange(b []byte) (r [2]pref.FieldNumber) {
return r return r
} }
func unmarshalMessageExtensionRange(b []byte) (r [2]pref.FieldNumber, rawOptions []byte) { func unmarshalMessageExtensionRange(b []byte) (r [2]protoreflect.FieldNumber, rawOptions []byte) {
for len(b) > 0 { for len(b) > 0 {
num, typ, n := protowire.ConsumeTag(b) num, typ, n := protowire.ConsumeTag(b)
b = b[n:] b = b[n:]
@ -391,9 +391,9 @@ func unmarshalMessageExtensionRange(b []byte) (r [2]pref.FieldNumber, rawOptions
b = b[m:] b = b[m:]
switch num { switch num {
case genid.DescriptorProto_ExtensionRange_Start_field_number: case genid.DescriptorProto_ExtensionRange_Start_field_number:
r[0] = pref.FieldNumber(v) r[0] = protoreflect.FieldNumber(v)
case genid.DescriptorProto_ExtensionRange_End_field_number: case genid.DescriptorProto_ExtensionRange_End_field_number:
r[1] = pref.FieldNumber(v) r[1] = protoreflect.FieldNumber(v)
} }
case protowire.BytesType: case protowire.BytesType:
v, m := protowire.ConsumeBytes(b) v, m := protowire.ConsumeBytes(b)
@ -410,7 +410,7 @@ func unmarshalMessageExtensionRange(b []byte) (r [2]pref.FieldNumber, rawOptions
return r, rawOptions return r, rawOptions
} }
func (fd *Field) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) { func (fd *Field) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
fd.L0.ParentFile = pf fd.L0.ParentFile = pf
fd.L0.Parent = pd fd.L0.Parent = pd
fd.L0.Index = i fd.L0.Index = i
@ -426,11 +426,11 @@ func (fd *Field) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Des
b = b[m:] b = b[m:]
switch num { switch num {
case genid.FieldDescriptorProto_Number_field_number: case genid.FieldDescriptorProto_Number_field_number:
fd.L1.Number = pref.FieldNumber(v) fd.L1.Number = protoreflect.FieldNumber(v)
case genid.FieldDescriptorProto_Label_field_number: case genid.FieldDescriptorProto_Label_field_number:
fd.L1.Cardinality = pref.Cardinality(v) fd.L1.Cardinality = protoreflect.Cardinality(v)
case genid.FieldDescriptorProto_Type_field_number: case genid.FieldDescriptorProto_Type_field_number:
fd.L1.Kind = pref.Kind(v) fd.L1.Kind = protoreflect.Kind(v)
case genid.FieldDescriptorProto_OneofIndex_field_number: case genid.FieldDescriptorProto_OneofIndex_field_number:
// In Message.unmarshalFull, we allocate slices for both // In Message.unmarshalFull, we allocate slices for both
// the field and oneof descriptors before unmarshaling either // the field and oneof descriptors before unmarshaling either
@ -453,7 +453,7 @@ func (fd *Field) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Des
case genid.FieldDescriptorProto_JsonName_field_number: case genid.FieldDescriptorProto_JsonName_field_number:
fd.L1.StringName.InitJSON(sb.MakeString(v)) fd.L1.StringName.InitJSON(sb.MakeString(v))
case genid.FieldDescriptorProto_DefaultValue_field_number: case genid.FieldDescriptorProto_DefaultValue_field_number:
fd.L1.Default.val = pref.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveMessages fd.L1.Default.val = protoreflect.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveMessages
case genid.FieldDescriptorProto_TypeName_field_number: case genid.FieldDescriptorProto_TypeName_field_number:
rawTypeName = v rawTypeName = v
case genid.FieldDescriptorProto_Options_field_number: case genid.FieldDescriptorProto_Options_field_number:
@ -468,9 +468,9 @@ func (fd *Field) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Des
if rawTypeName != nil { if rawTypeName != nil {
name := makeFullName(sb, rawTypeName) name := makeFullName(sb, rawTypeName)
switch fd.L1.Kind { switch fd.L1.Kind {
case pref.EnumKind: case protoreflect.EnumKind:
fd.L1.Enum = PlaceholderEnum(name) fd.L1.Enum = PlaceholderEnum(name)
case pref.MessageKind, pref.GroupKind: case protoreflect.MessageKind, protoreflect.GroupKind:
fd.L1.Message = PlaceholderMessage(name) fd.L1.Message = PlaceholderMessage(name)
} }
} }
@ -504,7 +504,7 @@ func (fd *Field) unmarshalOptions(b []byte) {
} }
} }
func (od *Oneof) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) { func (od *Oneof) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
od.L0.ParentFile = pf od.L0.ParentFile = pf
od.L0.Parent = pd od.L0.Parent = pd
od.L0.Index = i od.L0.Index = i
@ -553,7 +553,7 @@ func (xd *Extension) unmarshalFull(b []byte, sb *strs.Builder) {
case genid.FieldDescriptorProto_JsonName_field_number: case genid.FieldDescriptorProto_JsonName_field_number:
xd.L2.StringName.InitJSON(sb.MakeString(v)) xd.L2.StringName.InitJSON(sb.MakeString(v))
case genid.FieldDescriptorProto_DefaultValue_field_number: case genid.FieldDescriptorProto_DefaultValue_field_number:
xd.L2.Default.val = pref.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveExtensions xd.L2.Default.val = protoreflect.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveExtensions
case genid.FieldDescriptorProto_TypeName_field_number: case genid.FieldDescriptorProto_TypeName_field_number:
rawTypeName = v rawTypeName = v
case genid.FieldDescriptorProto_Options_field_number: case genid.FieldDescriptorProto_Options_field_number:
@ -568,9 +568,9 @@ func (xd *Extension) unmarshalFull(b []byte, sb *strs.Builder) {
if rawTypeName != nil { if rawTypeName != nil {
name := makeFullName(sb, rawTypeName) name := makeFullName(sb, rawTypeName)
switch xd.L1.Kind { switch xd.L1.Kind {
case pref.EnumKind: case protoreflect.EnumKind:
xd.L2.Enum = PlaceholderEnum(name) xd.L2.Enum = PlaceholderEnum(name)
case pref.MessageKind, pref.GroupKind: case protoreflect.MessageKind, protoreflect.GroupKind:
xd.L2.Message = PlaceholderMessage(name) xd.L2.Message = PlaceholderMessage(name)
} }
} }
@ -627,7 +627,7 @@ func (sd *Service) unmarshalFull(b []byte, sb *strs.Builder) {
sd.L2.Options = sd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Service, rawOptions) sd.L2.Options = sd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Service, rawOptions)
} }
func (md *Method) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) { func (md *Method) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoreflect.Descriptor, i int) {
md.L0.ParentFile = pf md.L0.ParentFile = pf
md.L0.Parent = pd md.L0.Parent = pd
md.L0.Index = i md.L0.Index = i
@ -680,18 +680,18 @@ func appendOptions(dst, src []byte) []byte {
// //
// The type of message to unmarshal to is passed as a pointer since the // The type of message to unmarshal to is passed as a pointer since the
// vars in descopts may not yet be populated at the time this function is called. // vars in descopts may not yet be populated at the time this function is called.
func (db *Builder) optionsUnmarshaler(p *pref.ProtoMessage, b []byte) func() pref.ProtoMessage { func (db *Builder) optionsUnmarshaler(p *protoreflect.ProtoMessage, b []byte) func() protoreflect.ProtoMessage {
if b == nil { if b == nil {
return nil return nil
} }
var opts pref.ProtoMessage var opts protoreflect.ProtoMessage
var once sync.Once var once sync.Once
return func() pref.ProtoMessage { return func() protoreflect.ProtoMessage {
once.Do(func() { once.Do(func() {
if *p == nil { if *p == nil {
panic("Descriptor.Options called without importing the descriptor package") panic("Descriptor.Options called without importing the descriptor package")
} }
opts = reflect.New(reflect.TypeOf(*p).Elem()).Interface().(pref.ProtoMessage) opts = reflect.New(reflect.TypeOf(*p).Elem()).Interface().(protoreflect.ProtoMessage)
if err := (proto.UnmarshalOptions{ if err := (proto.UnmarshalOptions{
AllowPartial: true, AllowPartial: true,
Resolver: db.TypeResolver, Resolver: db.TypeResolver,

View File

@ -17,31 +17,30 @@ import (
"google.golang.org/protobuf/internal/errors" "google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/internal/pragma" "google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
) )
type FileImports []pref.FileImport type FileImports []protoreflect.FileImport
func (p *FileImports) Len() int { return len(*p) } func (p *FileImports) Len() int { return len(*p) }
func (p *FileImports) Get(i int) pref.FileImport { return (*p)[i] } func (p *FileImports) Get(i int) protoreflect.FileImport { return (*p)[i] }
func (p *FileImports) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) } func (p *FileImports) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
func (p *FileImports) ProtoInternal(pragma.DoNotImplement) {} func (p *FileImports) ProtoInternal(pragma.DoNotImplement) {}
type Names struct { type Names struct {
List []pref.Name List []protoreflect.Name
once sync.Once once sync.Once
has map[pref.Name]int // protected by once has map[protoreflect.Name]int // protected by once
} }
func (p *Names) Len() int { return len(p.List) } func (p *Names) Len() int { return len(p.List) }
func (p *Names) Get(i int) pref.Name { return p.List[i] } func (p *Names) Get(i int) protoreflect.Name { return p.List[i] }
func (p *Names) Has(s pref.Name) bool { return p.lazyInit().has[s] > 0 } func (p *Names) Has(s protoreflect.Name) bool { return p.lazyInit().has[s] > 0 }
func (p *Names) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) } func (p *Names) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
func (p *Names) ProtoInternal(pragma.DoNotImplement) {} func (p *Names) ProtoInternal(pragma.DoNotImplement) {}
func (p *Names) lazyInit() *Names { func (p *Names) lazyInit() *Names {
p.once.Do(func() { p.once.Do(func() {
if len(p.List) > 0 { if len(p.List) > 0 {
p.has = make(map[pref.Name]int, len(p.List)) p.has = make(map[protoreflect.Name]int, len(p.List))
for _, s := range p.List { for _, s := range p.List {
p.has[s] = p.has[s] + 1 p.has[s] = p.has[s] + 1
} }
@ -67,14 +66,14 @@ func (p *Names) CheckValid() error {
} }
type EnumRanges struct { type EnumRanges struct {
List [][2]pref.EnumNumber // start inclusive; end inclusive List [][2]protoreflect.EnumNumber // start inclusive; end inclusive
once sync.Once once sync.Once
sorted [][2]pref.EnumNumber // protected by once sorted [][2]protoreflect.EnumNumber // protected by once
} }
func (p *EnumRanges) Len() int { return len(p.List) } func (p *EnumRanges) Len() int { return len(p.List) }
func (p *EnumRanges) Get(i int) [2]pref.EnumNumber { return p.List[i] } func (p *EnumRanges) Get(i int) [2]protoreflect.EnumNumber { return p.List[i] }
func (p *EnumRanges) Has(n pref.EnumNumber) bool { func (p *EnumRanges) Has(n protoreflect.EnumNumber) bool {
for ls := p.lazyInit().sorted; len(ls) > 0; { for ls := p.lazyInit().sorted; len(ls) > 0; {
i := len(ls) / 2 i := len(ls) / 2
switch r := enumRange(ls[i]); { switch r := enumRange(ls[i]); {
@ -129,14 +128,14 @@ func (r enumRange) String() string {
} }
type FieldRanges struct { type FieldRanges struct {
List [][2]pref.FieldNumber // start inclusive; end exclusive List [][2]protoreflect.FieldNumber // start inclusive; end exclusive
once sync.Once once sync.Once
sorted [][2]pref.FieldNumber // protected by once sorted [][2]protoreflect.FieldNumber // protected by once
} }
func (p *FieldRanges) Len() int { return len(p.List) } func (p *FieldRanges) Len() int { return len(p.List) }
func (p *FieldRanges) Get(i int) [2]pref.FieldNumber { return p.List[i] } func (p *FieldRanges) Get(i int) [2]protoreflect.FieldNumber { return p.List[i] }
func (p *FieldRanges) Has(n pref.FieldNumber) bool { func (p *FieldRanges) Has(n protoreflect.FieldNumber) bool {
for ls := p.lazyInit().sorted; len(ls) > 0; { for ls := p.lazyInit().sorted; len(ls) > 0; {
i := len(ls) / 2 i := len(ls) / 2
switch r := fieldRange(ls[i]); { switch r := fieldRange(ls[i]); {
@ -221,17 +220,17 @@ func (r fieldRange) String() string {
} }
type FieldNumbers struct { type FieldNumbers struct {
List []pref.FieldNumber List []protoreflect.FieldNumber
once sync.Once once sync.Once
has map[pref.FieldNumber]struct{} // protected by once has map[protoreflect.FieldNumber]struct{} // protected by once
} }
func (p *FieldNumbers) Len() int { return len(p.List) } func (p *FieldNumbers) Len() int { return len(p.List) }
func (p *FieldNumbers) Get(i int) pref.FieldNumber { return p.List[i] } func (p *FieldNumbers) Get(i int) protoreflect.FieldNumber { return p.List[i] }
func (p *FieldNumbers) Has(n pref.FieldNumber) bool { func (p *FieldNumbers) Has(n protoreflect.FieldNumber) bool {
p.once.Do(func() { p.once.Do(func() {
if len(p.List) > 0 { if len(p.List) > 0 {
p.has = make(map[pref.FieldNumber]struct{}, len(p.List)) p.has = make(map[protoreflect.FieldNumber]struct{}, len(p.List))
for _, n := range p.List { for _, n := range p.List {
p.has[n] = struct{}{} p.has[n] = struct{}{}
} }
@ -244,30 +243,38 @@ func (p *FieldNumbers) Format(s fmt.State, r rune) { descfmt.FormatList
func (p *FieldNumbers) ProtoInternal(pragma.DoNotImplement) {} func (p *FieldNumbers) ProtoInternal(pragma.DoNotImplement) {}
type OneofFields struct { type OneofFields struct {
List []pref.FieldDescriptor List []protoreflect.FieldDescriptor
once sync.Once once sync.Once
byName map[pref.Name]pref.FieldDescriptor // protected by once byName map[protoreflect.Name]protoreflect.FieldDescriptor // protected by once
byJSON map[string]pref.FieldDescriptor // protected by once byJSON map[string]protoreflect.FieldDescriptor // protected by once
byText map[string]pref.FieldDescriptor // protected by once byText map[string]protoreflect.FieldDescriptor // protected by once
byNum map[pref.FieldNumber]pref.FieldDescriptor // protected by once byNum map[protoreflect.FieldNumber]protoreflect.FieldDescriptor // protected by once
} }
func (p *OneofFields) Len() int { return len(p.List) } func (p *OneofFields) Len() int { return len(p.List) }
func (p *OneofFields) Get(i int) pref.FieldDescriptor { return p.List[i] } func (p *OneofFields) Get(i int) protoreflect.FieldDescriptor { return p.List[i] }
func (p *OneofFields) ByName(s pref.Name) pref.FieldDescriptor { return p.lazyInit().byName[s] } func (p *OneofFields) ByName(s protoreflect.Name) protoreflect.FieldDescriptor {
func (p *OneofFields) ByJSONName(s string) pref.FieldDescriptor { return p.lazyInit().byJSON[s] } return p.lazyInit().byName[s]
func (p *OneofFields) ByTextName(s string) pref.FieldDescriptor { return p.lazyInit().byText[s] } }
func (p *OneofFields) ByNumber(n pref.FieldNumber) pref.FieldDescriptor { return p.lazyInit().byNum[n] } func (p *OneofFields) ByJSONName(s string) protoreflect.FieldDescriptor {
return p.lazyInit().byJSON[s]
}
func (p *OneofFields) ByTextName(s string) protoreflect.FieldDescriptor {
return p.lazyInit().byText[s]
}
func (p *OneofFields) ByNumber(n protoreflect.FieldNumber) protoreflect.FieldDescriptor {
return p.lazyInit().byNum[n]
}
func (p *OneofFields) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) } func (p *OneofFields) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
func (p *OneofFields) ProtoInternal(pragma.DoNotImplement) {} func (p *OneofFields) ProtoInternal(pragma.DoNotImplement) {}
func (p *OneofFields) lazyInit() *OneofFields { func (p *OneofFields) lazyInit() *OneofFields {
p.once.Do(func() { p.once.Do(func() {
if len(p.List) > 0 { if len(p.List) > 0 {
p.byName = make(map[pref.Name]pref.FieldDescriptor, len(p.List)) p.byName = make(map[protoreflect.Name]protoreflect.FieldDescriptor, len(p.List))
p.byJSON = make(map[string]pref.FieldDescriptor, len(p.List)) p.byJSON = make(map[string]protoreflect.FieldDescriptor, len(p.List))
p.byText = make(map[string]pref.FieldDescriptor, len(p.List)) p.byText = make(map[string]protoreflect.FieldDescriptor, len(p.List))
p.byNum = make(map[pref.FieldNumber]pref.FieldDescriptor, len(p.List)) p.byNum = make(map[protoreflect.FieldNumber]protoreflect.FieldDescriptor, len(p.List))
for _, f := range p.List { for _, f := range p.List {
// Field names and numbers are guaranteed to be unique. // Field names and numbers are guaranteed to be unique.
p.byName[f.Name()] = f p.byName[f.Name()] = f
@ -284,123 +291,123 @@ type SourceLocations struct {
// List is a list of SourceLocations. // List is a list of SourceLocations.
// The SourceLocation.Next field does not need to be populated // The SourceLocation.Next field does not need to be populated
// as it will be lazily populated upon first need. // as it will be lazily populated upon first need.
List []pref.SourceLocation List []protoreflect.SourceLocation
// File is the parent file descriptor that these locations are relative to. // File is the parent file descriptor that these locations are relative to.
// If non-nil, ByDescriptor verifies that the provided descriptor // If non-nil, ByDescriptor verifies that the provided descriptor
// is a child of this file descriptor. // is a child of this file descriptor.
File pref.FileDescriptor File protoreflect.FileDescriptor
once sync.Once once sync.Once
byPath map[pathKey]int byPath map[pathKey]int
} }
func (p *SourceLocations) Len() int { return len(p.List) } func (p *SourceLocations) Len() int { return len(p.List) }
func (p *SourceLocations) Get(i int) pref.SourceLocation { return p.lazyInit().List[i] } func (p *SourceLocations) Get(i int) protoreflect.SourceLocation { return p.lazyInit().List[i] }
func (p *SourceLocations) byKey(k pathKey) pref.SourceLocation { func (p *SourceLocations) byKey(k pathKey) protoreflect.SourceLocation {
if i, ok := p.lazyInit().byPath[k]; ok { if i, ok := p.lazyInit().byPath[k]; ok {
return p.List[i] return p.List[i]
} }
return pref.SourceLocation{} return protoreflect.SourceLocation{}
} }
func (p *SourceLocations) ByPath(path pref.SourcePath) pref.SourceLocation { func (p *SourceLocations) ByPath(path protoreflect.SourcePath) protoreflect.SourceLocation {
return p.byKey(newPathKey(path)) return p.byKey(newPathKey(path))
} }
func (p *SourceLocations) ByDescriptor(desc pref.Descriptor) pref.SourceLocation { func (p *SourceLocations) ByDescriptor(desc protoreflect.Descriptor) protoreflect.SourceLocation {
if p.File != nil && desc != nil && p.File != desc.ParentFile() { if p.File != nil && desc != nil && p.File != desc.ParentFile() {
return pref.SourceLocation{} // mismatching parent files return protoreflect.SourceLocation{} // mismatching parent files
} }
var pathArr [16]int32 var pathArr [16]int32
path := pathArr[:0] path := pathArr[:0]
for { for {
switch desc.(type) { switch desc.(type) {
case pref.FileDescriptor: case protoreflect.FileDescriptor:
// Reverse the path since it was constructed in reverse. // Reverse the path since it was constructed in reverse.
for i, j := 0, len(path)-1; i < j; i, j = i+1, j-1 { for i, j := 0, len(path)-1; i < j; i, j = i+1, j-1 {
path[i], path[j] = path[j], path[i] path[i], path[j] = path[j], path[i]
} }
return p.byKey(newPathKey(path)) return p.byKey(newPathKey(path))
case pref.MessageDescriptor: case protoreflect.MessageDescriptor:
path = append(path, int32(desc.Index())) path = append(path, int32(desc.Index()))
desc = desc.Parent() desc = desc.Parent()
switch desc.(type) { switch desc.(type) {
case pref.FileDescriptor: case protoreflect.FileDescriptor:
path = append(path, int32(genid.FileDescriptorProto_MessageType_field_number)) path = append(path, int32(genid.FileDescriptorProto_MessageType_field_number))
case pref.MessageDescriptor: case protoreflect.MessageDescriptor:
path = append(path, int32(genid.DescriptorProto_NestedType_field_number)) path = append(path, int32(genid.DescriptorProto_NestedType_field_number))
default: default:
return pref.SourceLocation{} return protoreflect.SourceLocation{}
} }
case pref.FieldDescriptor: case protoreflect.FieldDescriptor:
isExtension := desc.(pref.FieldDescriptor).IsExtension() isExtension := desc.(protoreflect.FieldDescriptor).IsExtension()
path = append(path, int32(desc.Index())) path = append(path, int32(desc.Index()))
desc = desc.Parent() desc = desc.Parent()
if isExtension { if isExtension {
switch desc.(type) { switch desc.(type) {
case pref.FileDescriptor: case protoreflect.FileDescriptor:
path = append(path, int32(genid.FileDescriptorProto_Extension_field_number)) path = append(path, int32(genid.FileDescriptorProto_Extension_field_number))
case pref.MessageDescriptor: case protoreflect.MessageDescriptor:
path = append(path, int32(genid.DescriptorProto_Extension_field_number)) path = append(path, int32(genid.DescriptorProto_Extension_field_number))
default: default:
return pref.SourceLocation{} return protoreflect.SourceLocation{}
} }
} else { } else {
switch desc.(type) { switch desc.(type) {
case pref.MessageDescriptor: case protoreflect.MessageDescriptor:
path = append(path, int32(genid.DescriptorProto_Field_field_number)) path = append(path, int32(genid.DescriptorProto_Field_field_number))
default: default:
return pref.SourceLocation{} return protoreflect.SourceLocation{}
} }
} }
case pref.OneofDescriptor: case protoreflect.OneofDescriptor:
path = append(path, int32(desc.Index())) path = append(path, int32(desc.Index()))
desc = desc.Parent() desc = desc.Parent()
switch desc.(type) { switch desc.(type) {
case pref.MessageDescriptor: case protoreflect.MessageDescriptor:
path = append(path, int32(genid.DescriptorProto_OneofDecl_field_number)) path = append(path, int32(genid.DescriptorProto_OneofDecl_field_number))
default: default:
return pref.SourceLocation{} return protoreflect.SourceLocation{}
} }
case pref.EnumDescriptor: case protoreflect.EnumDescriptor:
path = append(path, int32(desc.Index())) path = append(path, int32(desc.Index()))
desc = desc.Parent() desc = desc.Parent()
switch desc.(type) { switch desc.(type) {
case pref.FileDescriptor: case protoreflect.FileDescriptor:
path = append(path, int32(genid.FileDescriptorProto_EnumType_field_number)) path = append(path, int32(genid.FileDescriptorProto_EnumType_field_number))
case pref.MessageDescriptor: case protoreflect.MessageDescriptor:
path = append(path, int32(genid.DescriptorProto_EnumType_field_number)) path = append(path, int32(genid.DescriptorProto_EnumType_field_number))
default: default:
return pref.SourceLocation{} return protoreflect.SourceLocation{}
} }
case pref.EnumValueDescriptor: case protoreflect.EnumValueDescriptor:
path = append(path, int32(desc.Index())) path = append(path, int32(desc.Index()))
desc = desc.Parent() desc = desc.Parent()
switch desc.(type) { switch desc.(type) {
case pref.EnumDescriptor: case protoreflect.EnumDescriptor:
path = append(path, int32(genid.EnumDescriptorProto_Value_field_number)) path = append(path, int32(genid.EnumDescriptorProto_Value_field_number))
default: default:
return pref.SourceLocation{} return protoreflect.SourceLocation{}
} }
case pref.ServiceDescriptor: case protoreflect.ServiceDescriptor:
path = append(path, int32(desc.Index())) path = append(path, int32(desc.Index()))
desc = desc.Parent() desc = desc.Parent()
switch desc.(type) { switch desc.(type) {
case pref.FileDescriptor: case protoreflect.FileDescriptor:
path = append(path, int32(genid.FileDescriptorProto_Service_field_number)) path = append(path, int32(genid.FileDescriptorProto_Service_field_number))
default: default:
return pref.SourceLocation{} return protoreflect.SourceLocation{}
} }
case pref.MethodDescriptor: case protoreflect.MethodDescriptor:
path = append(path, int32(desc.Index())) path = append(path, int32(desc.Index()))
desc = desc.Parent() desc = desc.Parent()
switch desc.(type) { switch desc.(type) {
case pref.ServiceDescriptor: case protoreflect.ServiceDescriptor:
path = append(path, int32(genid.ServiceDescriptorProto_Method_field_number)) path = append(path, int32(genid.ServiceDescriptorProto_Method_field_number))
default: default:
return pref.SourceLocation{} return protoreflect.SourceLocation{}
} }
default: default:
return pref.SourceLocation{} return protoreflect.SourceLocation{}
} }
} }
} }
@ -435,7 +442,7 @@ type pathKey struct {
str string // used if the path does not fit in arr str string // used if the path does not fit in arr
} }
func newPathKey(p pref.SourcePath) (k pathKey) { func newPathKey(p protoreflect.SourcePath) (k pathKey) {
if len(p) < len(k.arr) { if len(p) < len(k.arr) {
for i, ps := range p { for i, ps := range p {
if ps < 0 || math.MaxUint8 <= ps { if ps < 0 || math.MaxUint8 <= ps {

View File

@ -7,7 +7,7 @@ package filedesc
import ( import (
"google.golang.org/protobuf/internal/descopts" "google.golang.org/protobuf/internal/descopts"
"google.golang.org/protobuf/internal/pragma" "google.golang.org/protobuf/internal/pragma"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
var ( var (
@ -30,78 +30,80 @@ var (
// PlaceholderFile is a placeholder, representing only the file path. // PlaceholderFile is a placeholder, representing only the file path.
type PlaceholderFile string type PlaceholderFile string
func (f PlaceholderFile) ParentFile() pref.FileDescriptor { return f } func (f PlaceholderFile) ParentFile() protoreflect.FileDescriptor { return f }
func (f PlaceholderFile) Parent() pref.Descriptor { return nil } func (f PlaceholderFile) Parent() protoreflect.Descriptor { return nil }
func (f PlaceholderFile) Index() int { return 0 } func (f PlaceholderFile) Index() int { return 0 }
func (f PlaceholderFile) Syntax() pref.Syntax { return 0 } func (f PlaceholderFile) Syntax() protoreflect.Syntax { return 0 }
func (f PlaceholderFile) Name() pref.Name { return "" } func (f PlaceholderFile) Name() protoreflect.Name { return "" }
func (f PlaceholderFile) FullName() pref.FullName { return "" } func (f PlaceholderFile) FullName() protoreflect.FullName { return "" }
func (f PlaceholderFile) IsPlaceholder() bool { return true } func (f PlaceholderFile) IsPlaceholder() bool { return true }
func (f PlaceholderFile) Options() pref.ProtoMessage { return descopts.File } func (f PlaceholderFile) Options() protoreflect.ProtoMessage { return descopts.File }
func (f PlaceholderFile) Path() string { return string(f) } func (f PlaceholderFile) Path() string { return string(f) }
func (f PlaceholderFile) Package() pref.FullName { return "" } func (f PlaceholderFile) Package() protoreflect.FullName { return "" }
func (f PlaceholderFile) Imports() pref.FileImports { return emptyFiles } func (f PlaceholderFile) Imports() protoreflect.FileImports { return emptyFiles }
func (f PlaceholderFile) Messages() pref.MessageDescriptors { return emptyMessages } func (f PlaceholderFile) Messages() protoreflect.MessageDescriptors { return emptyMessages }
func (f PlaceholderFile) Enums() pref.EnumDescriptors { return emptyEnums } func (f PlaceholderFile) Enums() protoreflect.EnumDescriptors { return emptyEnums }
func (f PlaceholderFile) Extensions() pref.ExtensionDescriptors { return emptyExtensions } func (f PlaceholderFile) Extensions() protoreflect.ExtensionDescriptors { return emptyExtensions }
func (f PlaceholderFile) Services() pref.ServiceDescriptors { return emptyServices } func (f PlaceholderFile) Services() protoreflect.ServiceDescriptors { return emptyServices }
func (f PlaceholderFile) SourceLocations() pref.SourceLocations { return emptySourceLocations } func (f PlaceholderFile) SourceLocations() protoreflect.SourceLocations { return emptySourceLocations }
func (f PlaceholderFile) ProtoType(pref.FileDescriptor) { return } func (f PlaceholderFile) ProtoType(protoreflect.FileDescriptor) { return }
func (f PlaceholderFile) ProtoInternal(pragma.DoNotImplement) { return } func (f PlaceholderFile) ProtoInternal(pragma.DoNotImplement) { return }
// PlaceholderEnum is a placeholder, representing only the full name. // PlaceholderEnum is a placeholder, representing only the full name.
type PlaceholderEnum pref.FullName type PlaceholderEnum protoreflect.FullName
func (e PlaceholderEnum) ParentFile() pref.FileDescriptor { return nil } func (e PlaceholderEnum) ParentFile() protoreflect.FileDescriptor { return nil }
func (e PlaceholderEnum) Parent() pref.Descriptor { return nil } func (e PlaceholderEnum) Parent() protoreflect.Descriptor { return nil }
func (e PlaceholderEnum) Index() int { return 0 } func (e PlaceholderEnum) Index() int { return 0 }
func (e PlaceholderEnum) Syntax() pref.Syntax { return 0 } func (e PlaceholderEnum) Syntax() protoreflect.Syntax { return 0 }
func (e PlaceholderEnum) Name() pref.Name { return pref.FullName(e).Name() } func (e PlaceholderEnum) Name() protoreflect.Name { return protoreflect.FullName(e).Name() }
func (e PlaceholderEnum) FullName() pref.FullName { return pref.FullName(e) } func (e PlaceholderEnum) FullName() protoreflect.FullName { return protoreflect.FullName(e) }
func (e PlaceholderEnum) IsPlaceholder() bool { return true } func (e PlaceholderEnum) IsPlaceholder() bool { return true }
func (e PlaceholderEnum) Options() pref.ProtoMessage { return descopts.Enum } func (e PlaceholderEnum) Options() protoreflect.ProtoMessage { return descopts.Enum }
func (e PlaceholderEnum) Values() pref.EnumValueDescriptors { return emptyEnumValues } func (e PlaceholderEnum) Values() protoreflect.EnumValueDescriptors { return emptyEnumValues }
func (e PlaceholderEnum) ReservedNames() pref.Names { return emptyNames } func (e PlaceholderEnum) ReservedNames() protoreflect.Names { return emptyNames }
func (e PlaceholderEnum) ReservedRanges() pref.EnumRanges { return emptyEnumRanges } func (e PlaceholderEnum) ReservedRanges() protoreflect.EnumRanges { return emptyEnumRanges }
func (e PlaceholderEnum) ProtoType(pref.EnumDescriptor) { return } func (e PlaceholderEnum) ProtoType(protoreflect.EnumDescriptor) { return }
func (e PlaceholderEnum) ProtoInternal(pragma.DoNotImplement) { return } func (e PlaceholderEnum) ProtoInternal(pragma.DoNotImplement) { return }
// PlaceholderEnumValue is a placeholder, representing only the full name. // PlaceholderEnumValue is a placeholder, representing only the full name.
type PlaceholderEnumValue pref.FullName type PlaceholderEnumValue protoreflect.FullName
func (e PlaceholderEnumValue) ParentFile() pref.FileDescriptor { return nil } func (e PlaceholderEnumValue) ParentFile() protoreflect.FileDescriptor { return nil }
func (e PlaceholderEnumValue) Parent() pref.Descriptor { return nil } func (e PlaceholderEnumValue) Parent() protoreflect.Descriptor { return nil }
func (e PlaceholderEnumValue) Index() int { return 0 } func (e PlaceholderEnumValue) Index() int { return 0 }
func (e PlaceholderEnumValue) Syntax() pref.Syntax { return 0 } func (e PlaceholderEnumValue) Syntax() protoreflect.Syntax { return 0 }
func (e PlaceholderEnumValue) Name() pref.Name { return pref.FullName(e).Name() } func (e PlaceholderEnumValue) Name() protoreflect.Name { return protoreflect.FullName(e).Name() }
func (e PlaceholderEnumValue) FullName() pref.FullName { return pref.FullName(e) } func (e PlaceholderEnumValue) FullName() protoreflect.FullName { return protoreflect.FullName(e) }
func (e PlaceholderEnumValue) IsPlaceholder() bool { return true } func (e PlaceholderEnumValue) IsPlaceholder() bool { return true }
func (e PlaceholderEnumValue) Options() pref.ProtoMessage { return descopts.EnumValue } func (e PlaceholderEnumValue) Options() protoreflect.ProtoMessage { return descopts.EnumValue }
func (e PlaceholderEnumValue) Number() pref.EnumNumber { return 0 } func (e PlaceholderEnumValue) Number() protoreflect.EnumNumber { return 0 }
func (e PlaceholderEnumValue) ProtoType(pref.EnumValueDescriptor) { return } func (e PlaceholderEnumValue) ProtoType(protoreflect.EnumValueDescriptor) { return }
func (e PlaceholderEnumValue) ProtoInternal(pragma.DoNotImplement) { return } func (e PlaceholderEnumValue) ProtoInternal(pragma.DoNotImplement) { return }
// PlaceholderMessage is a placeholder, representing only the full name. // PlaceholderMessage is a placeholder, representing only the full name.
type PlaceholderMessage pref.FullName type PlaceholderMessage protoreflect.FullName
func (m PlaceholderMessage) ParentFile() pref.FileDescriptor { return nil } func (m PlaceholderMessage) ParentFile() protoreflect.FileDescriptor { return nil }
func (m PlaceholderMessage) Parent() pref.Descriptor { return nil } func (m PlaceholderMessage) Parent() protoreflect.Descriptor { return nil }
func (m PlaceholderMessage) Index() int { return 0 } func (m PlaceholderMessage) Index() int { return 0 }
func (m PlaceholderMessage) Syntax() pref.Syntax { return 0 } func (m PlaceholderMessage) Syntax() protoreflect.Syntax { return 0 }
func (m PlaceholderMessage) Name() pref.Name { return pref.FullName(m).Name() } func (m PlaceholderMessage) Name() protoreflect.Name { return protoreflect.FullName(m).Name() }
func (m PlaceholderMessage) FullName() pref.FullName { return pref.FullName(m) } func (m PlaceholderMessage) FullName() protoreflect.FullName { return protoreflect.FullName(m) }
func (m PlaceholderMessage) IsPlaceholder() bool { return true } func (m PlaceholderMessage) IsPlaceholder() bool { return true }
func (m PlaceholderMessage) Options() pref.ProtoMessage { return descopts.Message } func (m PlaceholderMessage) Options() protoreflect.ProtoMessage { return descopts.Message }
func (m PlaceholderMessage) IsMapEntry() bool { return false } func (m PlaceholderMessage) IsMapEntry() bool { return false }
func (m PlaceholderMessage) Fields() pref.FieldDescriptors { return emptyFields } func (m PlaceholderMessage) Fields() protoreflect.FieldDescriptors { return emptyFields }
func (m PlaceholderMessage) Oneofs() pref.OneofDescriptors { return emptyOneofs } func (m PlaceholderMessage) Oneofs() protoreflect.OneofDescriptors { return emptyOneofs }
func (m PlaceholderMessage) ReservedNames() pref.Names { return emptyNames } func (m PlaceholderMessage) ReservedNames() protoreflect.Names { return emptyNames }
func (m PlaceholderMessage) ReservedRanges() pref.FieldRanges { return emptyFieldRanges } func (m PlaceholderMessage) ReservedRanges() protoreflect.FieldRanges { return emptyFieldRanges }
func (m PlaceholderMessage) RequiredNumbers() pref.FieldNumbers { return emptyFieldNumbers } func (m PlaceholderMessage) RequiredNumbers() protoreflect.FieldNumbers { return emptyFieldNumbers }
func (m PlaceholderMessage) ExtensionRanges() pref.FieldRanges { return emptyFieldRanges } func (m PlaceholderMessage) ExtensionRanges() protoreflect.FieldRanges { return emptyFieldRanges }
func (m PlaceholderMessage) ExtensionRangeOptions(int) pref.ProtoMessage { panic("index out of range") } func (m PlaceholderMessage) ExtensionRangeOptions(int) protoreflect.ProtoMessage {
func (m PlaceholderMessage) Messages() pref.MessageDescriptors { return emptyMessages } panic("index out of range")
func (m PlaceholderMessage) Enums() pref.EnumDescriptors { return emptyEnums } }
func (m PlaceholderMessage) Extensions() pref.ExtensionDescriptors { return emptyExtensions } func (m PlaceholderMessage) Messages() protoreflect.MessageDescriptors { return emptyMessages }
func (m PlaceholderMessage) ProtoType(pref.MessageDescriptor) { return } func (m PlaceholderMessage) Enums() protoreflect.EnumDescriptors { return emptyEnums }
func (m PlaceholderMessage) Extensions() protoreflect.ExtensionDescriptors { return emptyExtensions }
func (m PlaceholderMessage) ProtoType(protoreflect.MessageDescriptor) { return }
func (m PlaceholderMessage) ProtoInternal(pragma.DoNotImplement) { return } func (m PlaceholderMessage) ProtoInternal(pragma.DoNotImplement) { return }

View File

@ -10,17 +10,16 @@ import (
"reflect" "reflect"
"google.golang.org/protobuf/internal/descopts" "google.golang.org/protobuf/internal/descopts"
fdesc "google.golang.org/protobuf/internal/filedesc" "google.golang.org/protobuf/internal/filedesc"
pimpl "google.golang.org/protobuf/internal/impl" pimpl "google.golang.org/protobuf/internal/impl"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
preg "google.golang.org/protobuf/reflect/protoregistry" "google.golang.org/protobuf/reflect/protoregistry"
) )
// Builder constructs type descriptors from a raw file descriptor // Builder constructs type descriptors from a raw file descriptor
// and associated Go types for each enum and message declaration. // and associated Go types for each enum and message declaration.
// //
// // # Flattened Ordering
// Flattened Ordering
// //
// The protobuf type system represents declarations as a tree. Certain nodes in // The protobuf type system represents declarations as a tree. Certain nodes in
// the tree require us to either associate it with a concrete Go type or to // the tree require us to either associate it with a concrete Go type or to
@ -52,7 +51,7 @@ import (
// that children themselves may have. // that children themselves may have.
type Builder struct { type Builder struct {
// File is the underlying file descriptor builder. // File is the underlying file descriptor builder.
File fdesc.Builder File filedesc.Builder
// GoTypes is a unique set of the Go types for all declarations and // GoTypes is a unique set of the Go types for all declarations and
// dependencies. Each type is represented as a zero value of the Go type. // dependencies. Each type is represented as a zero value of the Go type.
@ -108,22 +107,22 @@ type Builder struct {
// TypeRegistry is the registry to register each type descriptor. // TypeRegistry is the registry to register each type descriptor.
// If nil, it uses protoregistry.GlobalTypes. // If nil, it uses protoregistry.GlobalTypes.
TypeRegistry interface { TypeRegistry interface {
RegisterMessage(pref.MessageType) error RegisterMessage(protoreflect.MessageType) error
RegisterEnum(pref.EnumType) error RegisterEnum(protoreflect.EnumType) error
RegisterExtension(pref.ExtensionType) error RegisterExtension(protoreflect.ExtensionType) error
} }
} }
// Out is the output of the builder. // Out is the output of the builder.
type Out struct { type Out struct {
File pref.FileDescriptor File protoreflect.FileDescriptor
} }
func (tb Builder) Build() (out Out) { func (tb Builder) Build() (out Out) {
// Replace the resolver with one that resolves dependencies by index, // Replace the resolver with one that resolves dependencies by index,
// which is faster and more reliable than relying on the global registry. // which is faster and more reliable than relying on the global registry.
if tb.File.FileRegistry == nil { if tb.File.FileRegistry == nil {
tb.File.FileRegistry = preg.GlobalFiles tb.File.FileRegistry = protoregistry.GlobalFiles
} }
tb.File.FileRegistry = &resolverByIndex{ tb.File.FileRegistry = &resolverByIndex{
goTypes: tb.GoTypes, goTypes: tb.GoTypes,
@ -133,7 +132,7 @@ func (tb Builder) Build() (out Out) {
// Initialize registry if unpopulated. // Initialize registry if unpopulated.
if tb.TypeRegistry == nil { if tb.TypeRegistry == nil {
tb.TypeRegistry = preg.GlobalTypes tb.TypeRegistry = protoregistry.GlobalTypes
} }
fbOut := tb.File.Build() fbOut := tb.File.Build()
@ -183,23 +182,23 @@ func (tb Builder) Build() (out Out) {
for i := range fbOut.Messages { for i := range fbOut.Messages {
switch fbOut.Messages[i].Name() { switch fbOut.Messages[i].Name() {
case "FileOptions": case "FileOptions":
descopts.File = messageGoTypes[i].(pref.ProtoMessage) descopts.File = messageGoTypes[i].(protoreflect.ProtoMessage)
case "EnumOptions": case "EnumOptions":
descopts.Enum = messageGoTypes[i].(pref.ProtoMessage) descopts.Enum = messageGoTypes[i].(protoreflect.ProtoMessage)
case "EnumValueOptions": case "EnumValueOptions":
descopts.EnumValue = messageGoTypes[i].(pref.ProtoMessage) descopts.EnumValue = messageGoTypes[i].(protoreflect.ProtoMessage)
case "MessageOptions": case "MessageOptions":
descopts.Message = messageGoTypes[i].(pref.ProtoMessage) descopts.Message = messageGoTypes[i].(protoreflect.ProtoMessage)
case "FieldOptions": case "FieldOptions":
descopts.Field = messageGoTypes[i].(pref.ProtoMessage) descopts.Field = messageGoTypes[i].(protoreflect.ProtoMessage)
case "OneofOptions": case "OneofOptions":
descopts.Oneof = messageGoTypes[i].(pref.ProtoMessage) descopts.Oneof = messageGoTypes[i].(protoreflect.ProtoMessage)
case "ExtensionRangeOptions": case "ExtensionRangeOptions":
descopts.ExtensionRange = messageGoTypes[i].(pref.ProtoMessage) descopts.ExtensionRange = messageGoTypes[i].(protoreflect.ProtoMessage)
case "ServiceOptions": case "ServiceOptions":
descopts.Service = messageGoTypes[i].(pref.ProtoMessage) descopts.Service = messageGoTypes[i].(protoreflect.ProtoMessage)
case "MethodOptions": case "MethodOptions":
descopts.Method = messageGoTypes[i].(pref.ProtoMessage) descopts.Method = messageGoTypes[i].(protoreflect.ProtoMessage)
} }
} }
} }
@ -216,11 +215,11 @@ func (tb Builder) Build() (out Out) {
const listExtDeps = 2 const listExtDeps = 2
var goType reflect.Type var goType reflect.Type
switch fbOut.Extensions[i].L1.Kind { switch fbOut.Extensions[i].L1.Kind {
case pref.EnumKind: case protoreflect.EnumKind:
j := depIdxs.Get(tb.DependencyIndexes, listExtDeps, depIdx) j := depIdxs.Get(tb.DependencyIndexes, listExtDeps, depIdx)
goType = reflect.TypeOf(tb.GoTypes[j]) goType = reflect.TypeOf(tb.GoTypes[j])
depIdx++ depIdx++
case pref.MessageKind, pref.GroupKind: case protoreflect.MessageKind, protoreflect.GroupKind:
j := depIdxs.Get(tb.DependencyIndexes, listExtDeps, depIdx) j := depIdxs.Get(tb.DependencyIndexes, listExtDeps, depIdx)
goType = reflect.TypeOf(tb.GoTypes[j]) goType = reflect.TypeOf(tb.GoTypes[j])
depIdx++ depIdx++
@ -242,22 +241,22 @@ func (tb Builder) Build() (out Out) {
return out return out
} }
var goTypeForPBKind = map[pref.Kind]reflect.Type{ var goTypeForPBKind = map[protoreflect.Kind]reflect.Type{
pref.BoolKind: reflect.TypeOf(bool(false)), protoreflect.BoolKind: reflect.TypeOf(bool(false)),
pref.Int32Kind: reflect.TypeOf(int32(0)), protoreflect.Int32Kind: reflect.TypeOf(int32(0)),
pref.Sint32Kind: reflect.TypeOf(int32(0)), protoreflect.Sint32Kind: reflect.TypeOf(int32(0)),
pref.Sfixed32Kind: reflect.TypeOf(int32(0)), protoreflect.Sfixed32Kind: reflect.TypeOf(int32(0)),
pref.Int64Kind: reflect.TypeOf(int64(0)), protoreflect.Int64Kind: reflect.TypeOf(int64(0)),
pref.Sint64Kind: reflect.TypeOf(int64(0)), protoreflect.Sint64Kind: reflect.TypeOf(int64(0)),
pref.Sfixed64Kind: reflect.TypeOf(int64(0)), protoreflect.Sfixed64Kind: reflect.TypeOf(int64(0)),
pref.Uint32Kind: reflect.TypeOf(uint32(0)), protoreflect.Uint32Kind: reflect.TypeOf(uint32(0)),
pref.Fixed32Kind: reflect.TypeOf(uint32(0)), protoreflect.Fixed32Kind: reflect.TypeOf(uint32(0)),
pref.Uint64Kind: reflect.TypeOf(uint64(0)), protoreflect.Uint64Kind: reflect.TypeOf(uint64(0)),
pref.Fixed64Kind: reflect.TypeOf(uint64(0)), protoreflect.Fixed64Kind: reflect.TypeOf(uint64(0)),
pref.FloatKind: reflect.TypeOf(float32(0)), protoreflect.FloatKind: reflect.TypeOf(float32(0)),
pref.DoubleKind: reflect.TypeOf(float64(0)), protoreflect.DoubleKind: reflect.TypeOf(float64(0)),
pref.StringKind: reflect.TypeOf(string("")), protoreflect.StringKind: reflect.TypeOf(string("")),
pref.BytesKind: reflect.TypeOf([]byte(nil)), protoreflect.BytesKind: reflect.TypeOf([]byte(nil)),
} }
type depIdxs []int32 type depIdxs []int32
@ -274,13 +273,13 @@ type (
fileRegistry fileRegistry
} }
fileRegistry interface { fileRegistry interface {
FindFileByPath(string) (pref.FileDescriptor, error) FindFileByPath(string) (protoreflect.FileDescriptor, error)
FindDescriptorByName(pref.FullName) (pref.Descriptor, error) FindDescriptorByName(protoreflect.FullName) (protoreflect.Descriptor, error)
RegisterFile(pref.FileDescriptor) error RegisterFile(protoreflect.FileDescriptor) error
} }
) )
func (r *resolverByIndex) FindEnumByIndex(i, j int32, es []fdesc.Enum, ms []fdesc.Message) pref.EnumDescriptor { func (r *resolverByIndex) FindEnumByIndex(i, j int32, es []filedesc.Enum, ms []filedesc.Message) protoreflect.EnumDescriptor {
if depIdx := int(r.depIdxs.Get(i, j)); int(depIdx) < len(es)+len(ms) { if depIdx := int(r.depIdxs.Get(i, j)); int(depIdx) < len(es)+len(ms) {
return &es[depIdx] return &es[depIdx]
} else { } else {
@ -288,7 +287,7 @@ func (r *resolverByIndex) FindEnumByIndex(i, j int32, es []fdesc.Enum, ms []fdes
} }
} }
func (r *resolverByIndex) FindMessageByIndex(i, j int32, es []fdesc.Enum, ms []fdesc.Message) pref.MessageDescriptor { func (r *resolverByIndex) FindMessageByIndex(i, j int32, es []filedesc.Enum, ms []filedesc.Message) protoreflect.MessageDescriptor {
if depIdx := int(r.depIdxs.Get(i, j)); depIdx < len(es)+len(ms) { if depIdx := int(r.depIdxs.Get(i, j)); depIdx < len(es)+len(ms) {
return &ms[depIdx-len(es)] return &ms[depIdx-len(es)]
} else { } else {

View File

@ -12,8 +12,8 @@ import (
"google.golang.org/protobuf/encoding/prototext" "google.golang.org/protobuf/encoding/prototext"
"google.golang.org/protobuf/internal/errors" "google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/proto" "google.golang.org/protobuf/proto"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
piface "google.golang.org/protobuf/runtime/protoiface" "google.golang.org/protobuf/runtime/protoiface"
) )
// Export is a zero-length named type that exists only to export a set of // Export is a zero-length named type that exists only to export a set of
@ -32,11 +32,11 @@ type enum = interface{}
// EnumOf returns the protoreflect.Enum interface over e. // EnumOf returns the protoreflect.Enum interface over e.
// It returns nil if e is nil. // It returns nil if e is nil.
func (Export) EnumOf(e enum) pref.Enum { func (Export) EnumOf(e enum) protoreflect.Enum {
switch e := e.(type) { switch e := e.(type) {
case nil: case nil:
return nil return nil
case pref.Enum: case protoreflect.Enum:
return e return e
default: default:
return legacyWrapEnum(reflect.ValueOf(e)) return legacyWrapEnum(reflect.ValueOf(e))
@ -45,11 +45,11 @@ func (Export) EnumOf(e enum) pref.Enum {
// EnumDescriptorOf returns the protoreflect.EnumDescriptor for e. // EnumDescriptorOf returns the protoreflect.EnumDescriptor for e.
// It returns nil if e is nil. // It returns nil if e is nil.
func (Export) EnumDescriptorOf(e enum) pref.EnumDescriptor { func (Export) EnumDescriptorOf(e enum) protoreflect.EnumDescriptor {
switch e := e.(type) { switch e := e.(type) {
case nil: case nil:
return nil return nil
case pref.Enum: case protoreflect.Enum:
return e.Descriptor() return e.Descriptor()
default: default:
return LegacyLoadEnumDesc(reflect.TypeOf(e)) return LegacyLoadEnumDesc(reflect.TypeOf(e))
@ -58,11 +58,11 @@ func (Export) EnumDescriptorOf(e enum) pref.EnumDescriptor {
// EnumTypeOf returns the protoreflect.EnumType for e. // EnumTypeOf returns the protoreflect.EnumType for e.
// It returns nil if e is nil. // It returns nil if e is nil.
func (Export) EnumTypeOf(e enum) pref.EnumType { func (Export) EnumTypeOf(e enum) protoreflect.EnumType {
switch e := e.(type) { switch e := e.(type) {
case nil: case nil:
return nil return nil
case pref.Enum: case protoreflect.Enum:
return e.Type() return e.Type()
default: default:
return legacyLoadEnumType(reflect.TypeOf(e)) return legacyLoadEnumType(reflect.TypeOf(e))
@ -71,7 +71,7 @@ func (Export) EnumTypeOf(e enum) pref.EnumType {
// EnumStringOf returns the enum value as a string, either as the name if // EnumStringOf returns the enum value as a string, either as the name if
// the number is resolvable, or the number formatted as a string. // the number is resolvable, or the number formatted as a string.
func (Export) EnumStringOf(ed pref.EnumDescriptor, n pref.EnumNumber) string { func (Export) EnumStringOf(ed protoreflect.EnumDescriptor, n protoreflect.EnumNumber) string {
ev := ed.Values().ByNumber(n) ev := ed.Values().ByNumber(n)
if ev != nil { if ev != nil {
return string(ev.Name()) return string(ev.Name())
@ -84,7 +84,7 @@ func (Export) EnumStringOf(ed pref.EnumDescriptor, n pref.EnumNumber) string {
type message = interface{} type message = interface{}
// legacyMessageWrapper wraps a v2 message as a v1 message. // legacyMessageWrapper wraps a v2 message as a v1 message.
type legacyMessageWrapper struct{ m pref.ProtoMessage } type legacyMessageWrapper struct{ m protoreflect.ProtoMessage }
func (m legacyMessageWrapper) Reset() { proto.Reset(m.m) } func (m legacyMessageWrapper) Reset() { proto.Reset(m.m) }
func (m legacyMessageWrapper) String() string { return Export{}.MessageStringOf(m.m) } func (m legacyMessageWrapper) String() string { return Export{}.MessageStringOf(m.m) }
@ -92,30 +92,30 @@ func (m legacyMessageWrapper) ProtoMessage() {}
// ProtoMessageV1Of converts either a v1 or v2 message to a v1 message. // ProtoMessageV1Of converts either a v1 or v2 message to a v1 message.
// It returns nil if m is nil. // It returns nil if m is nil.
func (Export) ProtoMessageV1Of(m message) piface.MessageV1 { func (Export) ProtoMessageV1Of(m message) protoiface.MessageV1 {
switch mv := m.(type) { switch mv := m.(type) {
case nil: case nil:
return nil return nil
case piface.MessageV1: case protoiface.MessageV1:
return mv return mv
case unwrapper: case unwrapper:
return Export{}.ProtoMessageV1Of(mv.protoUnwrap()) return Export{}.ProtoMessageV1Of(mv.protoUnwrap())
case pref.ProtoMessage: case protoreflect.ProtoMessage:
return legacyMessageWrapper{mv} return legacyMessageWrapper{mv}
default: default:
panic(fmt.Sprintf("message %T is neither a v1 or v2 Message", m)) panic(fmt.Sprintf("message %T is neither a v1 or v2 Message", m))
} }
} }
func (Export) protoMessageV2Of(m message) pref.ProtoMessage { func (Export) protoMessageV2Of(m message) protoreflect.ProtoMessage {
switch mv := m.(type) { switch mv := m.(type) {
case nil: case nil:
return nil return nil
case pref.ProtoMessage: case protoreflect.ProtoMessage:
return mv return mv
case legacyMessageWrapper: case legacyMessageWrapper:
return mv.m return mv.m
case piface.MessageV1: case protoiface.MessageV1:
return nil return nil
default: default:
panic(fmt.Sprintf("message %T is neither a v1 or v2 Message", m)) panic(fmt.Sprintf("message %T is neither a v1 or v2 Message", m))
@ -124,7 +124,7 @@ func (Export) protoMessageV2Of(m message) pref.ProtoMessage {
// ProtoMessageV2Of converts either a v1 or v2 message to a v2 message. // ProtoMessageV2Of converts either a v1 or v2 message to a v2 message.
// It returns nil if m is nil. // It returns nil if m is nil.
func (Export) ProtoMessageV2Of(m message) pref.ProtoMessage { func (Export) ProtoMessageV2Of(m message) protoreflect.ProtoMessage {
if m == nil { if m == nil {
return nil return nil
} }
@ -136,7 +136,7 @@ func (Export) ProtoMessageV2Of(m message) pref.ProtoMessage {
// MessageOf returns the protoreflect.Message interface over m. // MessageOf returns the protoreflect.Message interface over m.
// It returns nil if m is nil. // It returns nil if m is nil.
func (Export) MessageOf(m message) pref.Message { func (Export) MessageOf(m message) protoreflect.Message {
if m == nil { if m == nil {
return nil return nil
} }
@ -148,7 +148,7 @@ func (Export) MessageOf(m message) pref.Message {
// MessageDescriptorOf returns the protoreflect.MessageDescriptor for m. // MessageDescriptorOf returns the protoreflect.MessageDescriptor for m.
// It returns nil if m is nil. // It returns nil if m is nil.
func (Export) MessageDescriptorOf(m message) pref.MessageDescriptor { func (Export) MessageDescriptorOf(m message) protoreflect.MessageDescriptor {
if m == nil { if m == nil {
return nil return nil
} }
@ -160,7 +160,7 @@ func (Export) MessageDescriptorOf(m message) pref.MessageDescriptor {
// MessageTypeOf returns the protoreflect.MessageType for m. // MessageTypeOf returns the protoreflect.MessageType for m.
// It returns nil if m is nil. // It returns nil if m is nil.
func (Export) MessageTypeOf(m message) pref.MessageType { func (Export) MessageTypeOf(m message) protoreflect.MessageType {
if m == nil { if m == nil {
return nil return nil
} }
@ -172,6 +172,6 @@ func (Export) MessageTypeOf(m message) pref.MessageType {
// MessageStringOf returns the message value as a string, // MessageStringOf returns the message value as a string,
// which is the message serialized in the protobuf text format. // which is the message serialized in the protobuf text format.
func (Export) MessageStringOf(m pref.ProtoMessage) string { func (Export) MessageStringOf(m protoreflect.ProtoMessage) string {
return prototext.MarshalOptions{Multiline: false}.Format(m) return prototext.MarshalOptions{Multiline: false}.Format(m)
} }

View File

@ -8,18 +8,18 @@ import (
"sync" "sync"
"google.golang.org/protobuf/internal/errors" "google.golang.org/protobuf/internal/errors"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
piface "google.golang.org/protobuf/runtime/protoiface" "google.golang.org/protobuf/runtime/protoiface"
) )
func (mi *MessageInfo) checkInitialized(in piface.CheckInitializedInput) (piface.CheckInitializedOutput, error) { func (mi *MessageInfo) checkInitialized(in protoiface.CheckInitializedInput) (protoiface.CheckInitializedOutput, error) {
var p pointer var p pointer
if ms, ok := in.Message.(*messageState); ok { if ms, ok := in.Message.(*messageState); ok {
p = ms.pointer() p = ms.pointer()
} else { } else {
p = in.Message.(*messageReflectWrapper).pointer() p = in.Message.(*messageReflectWrapper).pointer()
} }
return piface.CheckInitializedOutput{}, mi.checkInitializedPointer(p) return protoiface.CheckInitializedOutput{}, mi.checkInitializedPointer(p)
} }
func (mi *MessageInfo) checkInitializedPointer(p pointer) error { func (mi *MessageInfo) checkInitializedPointer(p pointer) error {
@ -90,7 +90,7 @@ var (
// needsInitCheck reports whether a message needs to be checked for partial initialization. // needsInitCheck reports whether a message needs to be checked for partial initialization.
// //
// It returns true if the message transitively includes any required or extension fields. // It returns true if the message transitively includes any required or extension fields.
func needsInitCheck(md pref.MessageDescriptor) bool { func needsInitCheck(md protoreflect.MessageDescriptor) bool {
if v, ok := needsInitCheckMap.Load(md); ok { if v, ok := needsInitCheckMap.Load(md); ok {
if has, ok := v.(bool); ok { if has, ok := v.(bool); ok {
return has return has
@ -101,7 +101,7 @@ func needsInitCheck(md pref.MessageDescriptor) bool {
return needsInitCheckLocked(md) return needsInitCheckLocked(md)
} }
func needsInitCheckLocked(md pref.MessageDescriptor) (has bool) { func needsInitCheckLocked(md protoreflect.MessageDescriptor) (has bool) {
if v, ok := needsInitCheckMap.Load(md); ok { if v, ok := needsInitCheckMap.Load(md); ok {
// If has is true, we've previously determined that this message // If has is true, we've previously determined that this message
// needs init checks. // needs init checks.

View File

@ -10,7 +10,7 @@ import (
"google.golang.org/protobuf/encoding/protowire" "google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/errors" "google.golang.org/protobuf/internal/errors"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
type extensionFieldInfo struct { type extensionFieldInfo struct {
@ -23,7 +23,7 @@ type extensionFieldInfo struct {
var legacyExtensionFieldInfoCache sync.Map // map[protoreflect.ExtensionType]*extensionFieldInfo var legacyExtensionFieldInfoCache sync.Map // map[protoreflect.ExtensionType]*extensionFieldInfo
func getExtensionFieldInfo(xt pref.ExtensionType) *extensionFieldInfo { func getExtensionFieldInfo(xt protoreflect.ExtensionType) *extensionFieldInfo {
if xi, ok := xt.(*ExtensionInfo); ok { if xi, ok := xt.(*ExtensionInfo); ok {
xi.lazyInit() xi.lazyInit()
return xi.info return xi.info
@ -32,7 +32,7 @@ func getExtensionFieldInfo(xt pref.ExtensionType) *extensionFieldInfo {
} }
// legacyLoadExtensionFieldInfo dynamically loads a *ExtensionInfo for xt. // legacyLoadExtensionFieldInfo dynamically loads a *ExtensionInfo for xt.
func legacyLoadExtensionFieldInfo(xt pref.ExtensionType) *extensionFieldInfo { func legacyLoadExtensionFieldInfo(xt protoreflect.ExtensionType) *extensionFieldInfo {
if xi, ok := legacyExtensionFieldInfoCache.Load(xt); ok { if xi, ok := legacyExtensionFieldInfoCache.Load(xt); ok {
return xi.(*extensionFieldInfo) return xi.(*extensionFieldInfo)
} }
@ -43,7 +43,7 @@ func legacyLoadExtensionFieldInfo(xt pref.ExtensionType) *extensionFieldInfo {
return e return e
} }
func makeExtensionFieldInfo(xd pref.ExtensionDescriptor) *extensionFieldInfo { func makeExtensionFieldInfo(xd protoreflect.ExtensionDescriptor) *extensionFieldInfo {
var wiretag uint64 var wiretag uint64
if !xd.IsPacked() { if !xd.IsPacked() {
wiretag = protowire.EncodeTag(xd.Number(), wireTypes[xd.Kind()]) wiretag = protowire.EncodeTag(xd.Number(), wireTypes[xd.Kind()])
@ -59,10 +59,10 @@ func makeExtensionFieldInfo(xd pref.ExtensionDescriptor) *extensionFieldInfo {
// This is true for composite types, where we pass in a message, list, or map to fill in, // This is true for composite types, where we pass in a message, list, or map to fill in,
// and for enums, where we pass in a prototype value to specify the concrete enum type. // and for enums, where we pass in a prototype value to specify the concrete enum type.
switch xd.Kind() { switch xd.Kind() {
case pref.MessageKind, pref.GroupKind, pref.EnumKind: case protoreflect.MessageKind, protoreflect.GroupKind, protoreflect.EnumKind:
e.unmarshalNeedsValue = true e.unmarshalNeedsValue = true
default: default:
if xd.Cardinality() == pref.Repeated { if xd.Cardinality() == protoreflect.Repeated {
e.unmarshalNeedsValue = true e.unmarshalNeedsValue = true
} }
} }
@ -73,21 +73,21 @@ type lazyExtensionValue struct {
atomicOnce uint32 // atomically set if value is valid atomicOnce uint32 // atomically set if value is valid
mu sync.Mutex mu sync.Mutex
xi *extensionFieldInfo xi *extensionFieldInfo
value pref.Value value protoreflect.Value
b []byte b []byte
fn func() pref.Value fn func() protoreflect.Value
} }
type ExtensionField struct { type ExtensionField struct {
typ pref.ExtensionType typ protoreflect.ExtensionType
// value is either the value of GetValue, // value is either the value of GetValue,
// or a *lazyExtensionValue that then returns the value of GetValue. // or a *lazyExtensionValue that then returns the value of GetValue.
value pref.Value value protoreflect.Value
lazy *lazyExtensionValue lazy *lazyExtensionValue
} }
func (f *ExtensionField) appendLazyBytes(xt pref.ExtensionType, xi *extensionFieldInfo, num protowire.Number, wtyp protowire.Type, b []byte) { func (f *ExtensionField) appendLazyBytes(xt protoreflect.ExtensionType, xi *extensionFieldInfo, num protowire.Number, wtyp protowire.Type, b []byte) {
if f.lazy == nil { if f.lazy == nil {
f.lazy = &lazyExtensionValue{xi: xi} f.lazy = &lazyExtensionValue{xi: xi}
} }
@ -97,7 +97,7 @@ func (f *ExtensionField) appendLazyBytes(xt pref.ExtensionType, xi *extensionFie
f.lazy.b = append(f.lazy.b, b...) f.lazy.b = append(f.lazy.b, b...)
} }
func (f *ExtensionField) canLazy(xt pref.ExtensionType) bool { func (f *ExtensionField) canLazy(xt protoreflect.ExtensionType) bool {
if f.typ == nil { if f.typ == nil {
return true return true
} }
@ -154,7 +154,7 @@ func (f *ExtensionField) lazyInit() {
// Set sets the type and value of the extension field. // Set sets the type and value of the extension field.
// This must not be called concurrently. // This must not be called concurrently.
func (f *ExtensionField) Set(t pref.ExtensionType, v pref.Value) { func (f *ExtensionField) Set(t protoreflect.ExtensionType, v protoreflect.Value) {
f.typ = t f.typ = t
f.value = v f.value = v
f.lazy = nil f.lazy = nil
@ -162,14 +162,14 @@ func (f *ExtensionField) Set(t pref.ExtensionType, v pref.Value) {
// SetLazy sets the type and a value that is to be lazily evaluated upon first use. // SetLazy sets the type and a value that is to be lazily evaluated upon first use.
// This must not be called concurrently. // This must not be called concurrently.
func (f *ExtensionField) SetLazy(t pref.ExtensionType, fn func() pref.Value) { func (f *ExtensionField) SetLazy(t protoreflect.ExtensionType, fn func() protoreflect.Value) {
f.typ = t f.typ = t
f.lazy = &lazyExtensionValue{fn: fn} f.lazy = &lazyExtensionValue{fn: fn}
} }
// Value returns the value of the extension field. // Value returns the value of the extension field.
// This may be called concurrently. // This may be called concurrently.
func (f *ExtensionField) Value() pref.Value { func (f *ExtensionField) Value() protoreflect.Value {
if f.lazy != nil { if f.lazy != nil {
if atomic.LoadUint32(&f.lazy.atomicOnce) == 0 { if atomic.LoadUint32(&f.lazy.atomicOnce) == 0 {
f.lazyInit() f.lazyInit()
@ -181,7 +181,7 @@ func (f *ExtensionField) Value() pref.Value {
// Type returns the type of the extension field. // Type returns the type of the extension field.
// This may be called concurrently. // This may be called concurrently.
func (f ExtensionField) Type() pref.ExtensionType { func (f ExtensionField) Type() protoreflect.ExtensionType {
return f.typ return f.typ
} }
@ -193,7 +193,7 @@ func (f ExtensionField) IsSet() bool {
// IsLazy reports whether a field is lazily encoded. // IsLazy reports whether a field is lazily encoded.
// It is exported for testing. // It is exported for testing.
func IsLazy(m pref.Message, fd pref.FieldDescriptor) bool { func IsLazy(m protoreflect.Message, fd protoreflect.FieldDescriptor) bool {
var mi *MessageInfo var mi *MessageInfo
var p pointer var p pointer
switch m := m.(type) { switch m := m.(type) {
@ -206,7 +206,7 @@ func IsLazy(m pref.Message, fd pref.FieldDescriptor) bool {
default: default:
return false return false
} }
xd, ok := fd.(pref.ExtensionTypeDescriptor) xd, ok := fd.(protoreflect.ExtensionTypeDescriptor)
if !ok { if !ok {
return false return false
} }

View File

@ -12,9 +12,9 @@ import (
"google.golang.org/protobuf/encoding/protowire" "google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/errors" "google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/proto" "google.golang.org/protobuf/proto"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
preg "google.golang.org/protobuf/reflect/protoregistry" "google.golang.org/protobuf/reflect/protoregistry"
piface "google.golang.org/protobuf/runtime/protoiface" "google.golang.org/protobuf/runtime/protoiface"
) )
type errInvalidUTF8 struct{} type errInvalidUTF8 struct{}
@ -30,7 +30,7 @@ func (errInvalidUTF8) Unwrap() error { return errors.Error }
// to the appropriate field-specific function as necessary. // to the appropriate field-specific function as necessary.
// //
// The unmarshal function is set on each field individually as usual. // The unmarshal function is set on each field individually as usual.
func (mi *MessageInfo) initOneofFieldCoders(od pref.OneofDescriptor, si structInfo) { func (mi *MessageInfo) initOneofFieldCoders(od protoreflect.OneofDescriptor, si structInfo) {
fs := si.oneofsByName[od.Name()] fs := si.oneofsByName[od.Name()]
ft := fs.Type ft := fs.Type
oneofFields := make(map[reflect.Type]*coderFieldInfo) oneofFields := make(map[reflect.Type]*coderFieldInfo)
@ -118,13 +118,13 @@ func (mi *MessageInfo) initOneofFieldCoders(od pref.OneofDescriptor, si structIn
} }
} }
func makeWeakMessageFieldCoder(fd pref.FieldDescriptor) pointerCoderFuncs { func makeWeakMessageFieldCoder(fd protoreflect.FieldDescriptor) pointerCoderFuncs {
var once sync.Once var once sync.Once
var messageType pref.MessageType var messageType protoreflect.MessageType
lazyInit := func() { lazyInit := func() {
once.Do(func() { once.Do(func() {
messageName := fd.Message().FullName() messageName := fd.Message().FullName()
messageType, _ = preg.GlobalTypes.FindMessageByName(messageName) messageType, _ = protoregistry.GlobalTypes.FindMessageByName(messageName)
}) })
} }
@ -190,7 +190,7 @@ func makeWeakMessageFieldCoder(fd pref.FieldDescriptor) pointerCoderFuncs {
} }
} }
func makeMessageFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs { func makeMessageFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
if mi := getMessageInfo(ft); mi != nil { if mi := getMessageInfo(ft); mi != nil {
funcs := pointerCoderFuncs{ funcs := pointerCoderFuncs{
size: sizeMessageInfo, size: sizeMessageInfo,
@ -280,7 +280,7 @@ func consumeMessage(b []byte, m proto.Message, wtyp protowire.Type, opts unmarsh
if n < 0 { if n < 0 {
return out, errDecode return out, errDecode
} }
o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{ o, err := opts.Options().UnmarshalState(protoiface.UnmarshalInput{
Buf: v, Buf: v,
Message: m.ProtoReflect(), Message: m.ProtoReflect(),
}) })
@ -288,27 +288,27 @@ func consumeMessage(b []byte, m proto.Message, wtyp protowire.Type, opts unmarsh
return out, err return out, err
} }
out.n = n out.n = n
out.initialized = o.Flags&piface.UnmarshalInitialized != 0 out.initialized = o.Flags&protoiface.UnmarshalInitialized != 0
return out, nil return out, nil
} }
func sizeMessageValue(v pref.Value, tagsize int, opts marshalOptions) int { func sizeMessageValue(v protoreflect.Value, tagsize int, opts marshalOptions) int {
m := v.Message().Interface() m := v.Message().Interface()
return sizeMessage(m, tagsize, opts) return sizeMessage(m, tagsize, opts)
} }
func appendMessageValue(b []byte, v pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error) { func appendMessageValue(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
m := v.Message().Interface() m := v.Message().Interface()
return appendMessage(b, m, wiretag, opts) return appendMessage(b, m, wiretag, opts)
} }
func consumeMessageValue(b []byte, v pref.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error) { func consumeMessageValue(b []byte, v protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (protoreflect.Value, unmarshalOutput, error) {
m := v.Message().Interface() m := v.Message().Interface()
out, err := consumeMessage(b, m, wtyp, opts) out, err := consumeMessage(b, m, wtyp, opts)
return v, out, err return v, out, err
} }
func isInitMessageValue(v pref.Value) error { func isInitMessageValue(v protoreflect.Value) error {
m := v.Message().Interface() m := v.Message().Interface()
return proto.CheckInitialized(m) return proto.CheckInitialized(m)
} }
@ -321,17 +321,17 @@ var coderMessageValue = valueCoderFuncs{
merge: mergeMessageValue, merge: mergeMessageValue,
} }
func sizeGroupValue(v pref.Value, tagsize int, opts marshalOptions) int { func sizeGroupValue(v protoreflect.Value, tagsize int, opts marshalOptions) int {
m := v.Message().Interface() m := v.Message().Interface()
return sizeGroup(m, tagsize, opts) return sizeGroup(m, tagsize, opts)
} }
func appendGroupValue(b []byte, v pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error) { func appendGroupValue(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
m := v.Message().Interface() m := v.Message().Interface()
return appendGroup(b, m, wiretag, opts) return appendGroup(b, m, wiretag, opts)
} }
func consumeGroupValue(b []byte, v pref.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error) { func consumeGroupValue(b []byte, v protoreflect.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (protoreflect.Value, unmarshalOutput, error) {
m := v.Message().Interface() m := v.Message().Interface()
out, err := consumeGroup(b, m, num, wtyp, opts) out, err := consumeGroup(b, m, num, wtyp, opts)
return v, out, err return v, out, err
@ -345,7 +345,7 @@ var coderGroupValue = valueCoderFuncs{
merge: mergeMessageValue, merge: mergeMessageValue,
} }
func makeGroupFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs { func makeGroupFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
num := fd.Number() num := fd.Number()
if mi := getMessageInfo(ft); mi != nil { if mi := getMessageInfo(ft); mi != nil {
funcs := pointerCoderFuncs{ funcs := pointerCoderFuncs{
@ -424,7 +424,7 @@ func consumeGroup(b []byte, m proto.Message, num protowire.Number, wtyp protowir
if n < 0 { if n < 0 {
return out, errDecode return out, errDecode
} }
o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{ o, err := opts.Options().UnmarshalState(protoiface.UnmarshalInput{
Buf: b, Buf: b,
Message: m.ProtoReflect(), Message: m.ProtoReflect(),
}) })
@ -432,11 +432,11 @@ func consumeGroup(b []byte, m proto.Message, num protowire.Number, wtyp protowir
return out, err return out, err
} }
out.n = n out.n = n
out.initialized = o.Flags&piface.UnmarshalInitialized != 0 out.initialized = o.Flags&protoiface.UnmarshalInitialized != 0
return out, nil return out, nil
} }
func makeMessageSliceFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs { func makeMessageSliceFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
if mi := getMessageInfo(ft); mi != nil { if mi := getMessageInfo(ft); mi != nil {
funcs := pointerCoderFuncs{ funcs := pointerCoderFuncs{
size: sizeMessageSliceInfo, size: sizeMessageSliceInfo,
@ -555,7 +555,7 @@ func consumeMessageSlice(b []byte, p pointer, goType reflect.Type, wtyp protowir
return out, errDecode return out, errDecode
} }
mp := reflect.New(goType.Elem()) mp := reflect.New(goType.Elem())
o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{ o, err := opts.Options().UnmarshalState(protoiface.UnmarshalInput{
Buf: v, Buf: v,
Message: asMessage(mp).ProtoReflect(), Message: asMessage(mp).ProtoReflect(),
}) })
@ -564,7 +564,7 @@ func consumeMessageSlice(b []byte, p pointer, goType reflect.Type, wtyp protowir
} }
p.AppendPointerSlice(pointerOfValue(mp)) p.AppendPointerSlice(pointerOfValue(mp))
out.n = n out.n = n
out.initialized = o.Flags&piface.UnmarshalInitialized != 0 out.initialized = o.Flags&protoiface.UnmarshalInitialized != 0
return out, nil return out, nil
} }
@ -581,7 +581,7 @@ func isInitMessageSlice(p pointer, goType reflect.Type) error {
// Slices of messages // Slices of messages
func sizeMessageSliceValue(listv pref.Value, tagsize int, opts marshalOptions) int { func sizeMessageSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) int {
list := listv.List() list := listv.List()
n := 0 n := 0
for i, llen := 0, list.Len(); i < llen; i++ { for i, llen := 0, list.Len(); i < llen; i++ {
@ -591,7 +591,7 @@ func sizeMessageSliceValue(listv pref.Value, tagsize int, opts marshalOptions) i
return n return n
} }
func appendMessageSliceValue(b []byte, listv pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error) { func appendMessageSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List() list := listv.List()
mopts := opts.Options() mopts := opts.Options()
for i, llen := 0, list.Len(); i < llen; i++ { for i, llen := 0, list.Len(); i < llen; i++ {
@ -608,30 +608,30 @@ func appendMessageSliceValue(b []byte, listv pref.Value, wiretag uint64, opts ma
return b, nil return b, nil
} }
func consumeMessageSliceValue(b []byte, listv pref.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ pref.Value, out unmarshalOutput, err error) { func consumeMessageSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List() list := listv.List()
if wtyp != protowire.BytesType { if wtyp != protowire.BytesType {
return pref.Value{}, out, errUnknown return protoreflect.Value{}, out, errUnknown
} }
v, n := protowire.ConsumeBytes(b) v, n := protowire.ConsumeBytes(b)
if n < 0 { if n < 0 {
return pref.Value{}, out, errDecode return protoreflect.Value{}, out, errDecode
} }
m := list.NewElement() m := list.NewElement()
o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{ o, err := opts.Options().UnmarshalState(protoiface.UnmarshalInput{
Buf: v, Buf: v,
Message: m.Message(), Message: m.Message(),
}) })
if err != nil { if err != nil {
return pref.Value{}, out, err return protoreflect.Value{}, out, err
} }
list.Append(m) list.Append(m)
out.n = n out.n = n
out.initialized = o.Flags&piface.UnmarshalInitialized != 0 out.initialized = o.Flags&protoiface.UnmarshalInitialized != 0
return listv, out, nil return listv, out, nil
} }
func isInitMessageSliceValue(listv pref.Value) error { func isInitMessageSliceValue(listv protoreflect.Value) error {
list := listv.List() list := listv.List()
for i, llen := 0, list.Len(); i < llen; i++ { for i, llen := 0, list.Len(); i < llen; i++ {
m := list.Get(i).Message().Interface() m := list.Get(i).Message().Interface()
@ -650,7 +650,7 @@ var coderMessageSliceValue = valueCoderFuncs{
merge: mergeMessageListValue, merge: mergeMessageListValue,
} }
func sizeGroupSliceValue(listv pref.Value, tagsize int, opts marshalOptions) int { func sizeGroupSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) int {
list := listv.List() list := listv.List()
n := 0 n := 0
for i, llen := 0, list.Len(); i < llen; i++ { for i, llen := 0, list.Len(); i < llen; i++ {
@ -660,7 +660,7 @@ func sizeGroupSliceValue(listv pref.Value, tagsize int, opts marshalOptions) int
return n return n
} }
func appendGroupSliceValue(b []byte, listv pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error) { func appendGroupSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
list := listv.List() list := listv.List()
mopts := opts.Options() mopts := opts.Options()
for i, llen := 0, list.Len(); i < llen; i++ { for i, llen := 0, list.Len(); i < llen; i++ {
@ -676,26 +676,26 @@ func appendGroupSliceValue(b []byte, listv pref.Value, wiretag uint64, opts mars
return b, nil return b, nil
} }
func consumeGroupSliceValue(b []byte, listv pref.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ pref.Value, out unmarshalOutput, err error) { func consumeGroupSliceValue(b []byte, listv protoreflect.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
list := listv.List() list := listv.List()
if wtyp != protowire.StartGroupType { if wtyp != protowire.StartGroupType {
return pref.Value{}, out, errUnknown return protoreflect.Value{}, out, errUnknown
} }
b, n := protowire.ConsumeGroup(num, b) b, n := protowire.ConsumeGroup(num, b)
if n < 0 { if n < 0 {
return pref.Value{}, out, errDecode return protoreflect.Value{}, out, errDecode
} }
m := list.NewElement() m := list.NewElement()
o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{ o, err := opts.Options().UnmarshalState(protoiface.UnmarshalInput{
Buf: b, Buf: b,
Message: m.Message(), Message: m.Message(),
}) })
if err != nil { if err != nil {
return pref.Value{}, out, err return protoreflect.Value{}, out, err
} }
list.Append(m) list.Append(m)
out.n = n out.n = n
out.initialized = o.Flags&piface.UnmarshalInitialized != 0 out.initialized = o.Flags&protoiface.UnmarshalInitialized != 0
return listv, out, nil return listv, out, nil
} }
@ -707,7 +707,7 @@ var coderGroupSliceValue = valueCoderFuncs{
merge: mergeMessageListValue, merge: mergeMessageListValue,
} }
func makeGroupSliceFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs { func makeGroupSliceFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
num := fd.Number() num := fd.Number()
if mi := getMessageInfo(ft); mi != nil { if mi := getMessageInfo(ft); mi != nil {
funcs := pointerCoderFuncs{ funcs := pointerCoderFuncs{
@ -772,7 +772,7 @@ func consumeGroupSlice(b []byte, p pointer, num protowire.Number, wtyp protowire
return out, errDecode return out, errDecode
} }
mp := reflect.New(goType.Elem()) mp := reflect.New(goType.Elem())
o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{ o, err := opts.Options().UnmarshalState(protoiface.UnmarshalInput{
Buf: b, Buf: b,
Message: asMessage(mp).ProtoReflect(), Message: asMessage(mp).ProtoReflect(),
}) })
@ -781,7 +781,7 @@ func consumeGroupSlice(b []byte, p pointer, num protowire.Number, wtyp protowire
} }
p.AppendPointerSlice(pointerOfValue(mp)) p.AppendPointerSlice(pointerOfValue(mp))
out.n = n out.n = n
out.initialized = o.Flags&piface.UnmarshalInitialized != 0 out.initialized = o.Flags&protoiface.UnmarshalInitialized != 0
return out, nil return out, nil
} }
@ -822,8 +822,8 @@ func consumeGroupSliceInfo(b []byte, p pointer, wtyp protowire.Type, f *coderFie
return out, nil return out, nil
} }
func asMessage(v reflect.Value) pref.ProtoMessage { func asMessage(v reflect.Value) protoreflect.ProtoMessage {
if m, ok := v.Interface().(pref.ProtoMessage); ok { if m, ok := v.Interface().(protoreflect.ProtoMessage); ok {
return m return m
} }
return legacyWrapMessage(v).Interface() return legacyWrapMessage(v).Interface()

View File

@ -10,7 +10,7 @@ import (
"google.golang.org/protobuf/encoding/protowire" "google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/genid" "google.golang.org/protobuf/internal/genid"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
type mapInfo struct { type mapInfo struct {
@ -19,12 +19,12 @@ type mapInfo struct {
valWiretag uint64 valWiretag uint64
keyFuncs valueCoderFuncs keyFuncs valueCoderFuncs
valFuncs valueCoderFuncs valFuncs valueCoderFuncs
keyZero pref.Value keyZero protoreflect.Value
keyKind pref.Kind keyKind protoreflect.Kind
conv *mapConverter conv *mapConverter
} }
func encoderFuncsForMap(fd pref.FieldDescriptor, ft reflect.Type) (valueMessage *MessageInfo, funcs pointerCoderFuncs) { func encoderFuncsForMap(fd protoreflect.FieldDescriptor, ft reflect.Type) (valueMessage *MessageInfo, funcs pointerCoderFuncs) {
// TODO: Consider generating specialized map coders. // TODO: Consider generating specialized map coders.
keyField := fd.MapKey() keyField := fd.MapKey()
valField := fd.MapValue() valField := fd.MapValue()
@ -44,7 +44,7 @@ func encoderFuncsForMap(fd pref.FieldDescriptor, ft reflect.Type) (valueMessage
keyKind: keyField.Kind(), keyKind: keyField.Kind(),
conv: conv, conv: conv,
} }
if valField.Kind() == pref.MessageKind { if valField.Kind() == protoreflect.MessageKind {
valueMessage = getMessageInfo(ft.Elem()) valueMessage = getMessageInfo(ft.Elem())
} }
@ -68,9 +68,9 @@ func encoderFuncsForMap(fd pref.FieldDescriptor, ft reflect.Type) (valueMessage
}, },
} }
switch valField.Kind() { switch valField.Kind() {
case pref.MessageKind: case protoreflect.MessageKind:
funcs.merge = mergeMapOfMessage funcs.merge = mergeMapOfMessage
case pref.BytesKind: case protoreflect.BytesKind:
funcs.merge = mergeMapOfBytes funcs.merge = mergeMapOfBytes
default: default:
funcs.merge = mergeMap funcs.merge = mergeMap
@ -135,7 +135,7 @@ func consumeMap(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi *mapInfo
err := errUnknown err := errUnknown
switch num { switch num {
case genid.MapEntry_Key_field_number: case genid.MapEntry_Key_field_number:
var v pref.Value var v protoreflect.Value
var o unmarshalOutput var o unmarshalOutput
v, o, err = mapi.keyFuncs.unmarshal(b, key, num, wtyp, opts) v, o, err = mapi.keyFuncs.unmarshal(b, key, num, wtyp, opts)
if err != nil { if err != nil {
@ -144,7 +144,7 @@ func consumeMap(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi *mapInfo
key = v key = v
n = o.n n = o.n
case genid.MapEntry_Value_field_number: case genid.MapEntry_Value_field_number:
var v pref.Value var v protoreflect.Value
var o unmarshalOutput var o unmarshalOutput
v, o, err = mapi.valFuncs.unmarshal(b, val, num, wtyp, opts) v, o, err = mapi.valFuncs.unmarshal(b, val, num, wtyp, opts)
if err != nil { if err != nil {
@ -192,7 +192,7 @@ func consumeMapOfMessage(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi
err := errUnknown err := errUnknown
switch num { switch num {
case 1: case 1:
var v pref.Value var v protoreflect.Value
var o unmarshalOutput var o unmarshalOutput
v, o, err = mapi.keyFuncs.unmarshal(b, key, num, wtyp, opts) v, o, err = mapi.keyFuncs.unmarshal(b, key, num, wtyp, opts)
if err != nil { if err != nil {

View File

@ -12,15 +12,15 @@ import (
"google.golang.org/protobuf/encoding/protowire" "google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/encoding/messageset" "google.golang.org/protobuf/internal/encoding/messageset"
"google.golang.org/protobuf/internal/order" "google.golang.org/protobuf/internal/order"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
piface "google.golang.org/protobuf/runtime/protoiface" "google.golang.org/protobuf/runtime/protoiface"
) )
// coderMessageInfo contains per-message information used by the fast-path functions. // coderMessageInfo contains per-message information used by the fast-path functions.
// This is a different type from MessageInfo to keep MessageInfo as general-purpose as // This is a different type from MessageInfo to keep MessageInfo as general-purpose as
// possible. // possible.
type coderMessageInfo struct { type coderMessageInfo struct {
methods piface.Methods methods protoiface.Methods
orderedCoderFields []*coderFieldInfo orderedCoderFields []*coderFieldInfo
denseCoderFields []*coderFieldInfo denseCoderFields []*coderFieldInfo
@ -39,7 +39,7 @@ type coderFieldInfo struct {
mi *MessageInfo // field's message mi *MessageInfo // field's message
ft reflect.Type ft reflect.Type
validation validationInfo // information used by message validation validation validationInfo // information used by message validation
num pref.FieldNumber // field number num protoreflect.FieldNumber // field number
offset offset // struct field offset offset offset // struct field offset
wiretag uint64 // field tag (number + wire type) wiretag uint64 // field tag (number + wire type)
tagsize int // size of the varint-encoded tag tagsize int // size of the varint-encoded tag
@ -125,8 +125,8 @@ func (mi *MessageInfo) makeCoderMethods(t reflect.Type, si structInfo) {
funcs: funcs, funcs: funcs,
mi: childMessage, mi: childMessage,
validation: newFieldValidationInfo(mi, si, fd, ft), validation: newFieldValidationInfo(mi, si, fd, ft),
isPointer: fd.Cardinality() == pref.Repeated || fd.HasPresence(), isPointer: fd.Cardinality() == protoreflect.Repeated || fd.HasPresence(),
isRequired: fd.Cardinality() == pref.Required, isRequired: fd.Cardinality() == protoreflect.Required,
} }
mi.orderedCoderFields = append(mi.orderedCoderFields, cf) mi.orderedCoderFields = append(mi.orderedCoderFields, cf)
mi.coderFields[cf.num] = cf mi.coderFields[cf.num] = cf
@ -149,7 +149,7 @@ func (mi *MessageInfo) makeCoderMethods(t reflect.Type, si structInfo) {
return mi.orderedCoderFields[i].num < mi.orderedCoderFields[j].num return mi.orderedCoderFields[i].num < mi.orderedCoderFields[j].num
}) })
var maxDense pref.FieldNumber var maxDense protoreflect.FieldNumber
for _, cf := range mi.orderedCoderFields { for _, cf := range mi.orderedCoderFields {
if cf.num >= 16 && cf.num >= 2*maxDense { if cf.num >= 16 && cf.num >= 2*maxDense {
break break
@ -175,12 +175,12 @@ func (mi *MessageInfo) makeCoderMethods(t reflect.Type, si structInfo) {
mi.needsInitCheck = needsInitCheck(mi.Desc) mi.needsInitCheck = needsInitCheck(mi.Desc)
if mi.methods.Marshal == nil && mi.methods.Size == nil { if mi.methods.Marshal == nil && mi.methods.Size == nil {
mi.methods.Flags |= piface.SupportMarshalDeterministic mi.methods.Flags |= protoiface.SupportMarshalDeterministic
mi.methods.Marshal = mi.marshal mi.methods.Marshal = mi.marshal
mi.methods.Size = mi.size mi.methods.Size = mi.size
} }
if mi.methods.Unmarshal == nil { if mi.methods.Unmarshal == nil {
mi.methods.Flags |= piface.SupportUnmarshalDiscardUnknown mi.methods.Flags |= protoiface.SupportUnmarshalDiscardUnknown
mi.methods.Unmarshal = mi.unmarshal mi.methods.Unmarshal = mi.unmarshal
} }
if mi.methods.CheckInitialized == nil { if mi.methods.CheckInitialized == nil {

View File

@ -10,7 +10,7 @@ import (
"google.golang.org/protobuf/encoding/protowire" "google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/strs" "google.golang.org/protobuf/internal/strs"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
// pointerCoderFuncs is a set of pointer encoding functions. // pointerCoderFuncs is a set of pointer encoding functions.
@ -25,83 +25,83 @@ type pointerCoderFuncs struct {
// valueCoderFuncs is a set of protoreflect.Value encoding functions. // valueCoderFuncs is a set of protoreflect.Value encoding functions.
type valueCoderFuncs struct { type valueCoderFuncs struct {
size func(v pref.Value, tagsize int, opts marshalOptions) int size func(v protoreflect.Value, tagsize int, opts marshalOptions) int
marshal func(b []byte, v pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error) marshal func(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error)
unmarshal func(b []byte, v pref.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error) unmarshal func(b []byte, v protoreflect.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (protoreflect.Value, unmarshalOutput, error)
isInit func(v pref.Value) error isInit func(v protoreflect.Value) error
merge func(dst, src pref.Value, opts mergeOptions) pref.Value merge func(dst, src protoreflect.Value, opts mergeOptions) protoreflect.Value
} }
// fieldCoder returns pointer functions for a field, used for operating on // fieldCoder returns pointer functions for a field, used for operating on
// struct fields. // struct fields.
func fieldCoder(fd pref.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointerCoderFuncs) { func fieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointerCoderFuncs) {
switch { switch {
case fd.IsMap(): case fd.IsMap():
return encoderFuncsForMap(fd, ft) return encoderFuncsForMap(fd, ft)
case fd.Cardinality() == pref.Repeated && !fd.IsPacked(): case fd.Cardinality() == protoreflect.Repeated && !fd.IsPacked():
// Repeated fields (not packed). // Repeated fields (not packed).
if ft.Kind() != reflect.Slice { if ft.Kind() != reflect.Slice {
break break
} }
ft := ft.Elem() ft := ft.Elem()
switch fd.Kind() { switch fd.Kind() {
case pref.BoolKind: case protoreflect.BoolKind:
if ft.Kind() == reflect.Bool { if ft.Kind() == reflect.Bool {
return nil, coderBoolSlice return nil, coderBoolSlice
} }
case pref.EnumKind: case protoreflect.EnumKind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderEnumSlice return nil, coderEnumSlice
} }
case pref.Int32Kind: case protoreflect.Int32Kind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderInt32Slice return nil, coderInt32Slice
} }
case pref.Sint32Kind: case protoreflect.Sint32Kind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderSint32Slice return nil, coderSint32Slice
} }
case pref.Uint32Kind: case protoreflect.Uint32Kind:
if ft.Kind() == reflect.Uint32 { if ft.Kind() == reflect.Uint32 {
return nil, coderUint32Slice return nil, coderUint32Slice
} }
case pref.Int64Kind: case protoreflect.Int64Kind:
if ft.Kind() == reflect.Int64 { if ft.Kind() == reflect.Int64 {
return nil, coderInt64Slice return nil, coderInt64Slice
} }
case pref.Sint64Kind: case protoreflect.Sint64Kind:
if ft.Kind() == reflect.Int64 { if ft.Kind() == reflect.Int64 {
return nil, coderSint64Slice return nil, coderSint64Slice
} }
case pref.Uint64Kind: case protoreflect.Uint64Kind:
if ft.Kind() == reflect.Uint64 { if ft.Kind() == reflect.Uint64 {
return nil, coderUint64Slice return nil, coderUint64Slice
} }
case pref.Sfixed32Kind: case protoreflect.Sfixed32Kind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderSfixed32Slice return nil, coderSfixed32Slice
} }
case pref.Fixed32Kind: case protoreflect.Fixed32Kind:
if ft.Kind() == reflect.Uint32 { if ft.Kind() == reflect.Uint32 {
return nil, coderFixed32Slice return nil, coderFixed32Slice
} }
case pref.FloatKind: case protoreflect.FloatKind:
if ft.Kind() == reflect.Float32 { if ft.Kind() == reflect.Float32 {
return nil, coderFloatSlice return nil, coderFloatSlice
} }
case pref.Sfixed64Kind: case protoreflect.Sfixed64Kind:
if ft.Kind() == reflect.Int64 { if ft.Kind() == reflect.Int64 {
return nil, coderSfixed64Slice return nil, coderSfixed64Slice
} }
case pref.Fixed64Kind: case protoreflect.Fixed64Kind:
if ft.Kind() == reflect.Uint64 { if ft.Kind() == reflect.Uint64 {
return nil, coderFixed64Slice return nil, coderFixed64Slice
} }
case pref.DoubleKind: case protoreflect.DoubleKind:
if ft.Kind() == reflect.Float64 { if ft.Kind() == reflect.Float64 {
return nil, coderDoubleSlice return nil, coderDoubleSlice
} }
case pref.StringKind: case protoreflect.StringKind:
if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) { if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
return nil, coderStringSliceValidateUTF8 return nil, coderStringSliceValidateUTF8
} }
@ -114,19 +114,19 @@ func fieldCoder(fd pref.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointer
if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 { if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
return nil, coderBytesSlice return nil, coderBytesSlice
} }
case pref.BytesKind: case protoreflect.BytesKind:
if ft.Kind() == reflect.String { if ft.Kind() == reflect.String {
return nil, coderStringSlice return nil, coderStringSlice
} }
if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 { if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
return nil, coderBytesSlice return nil, coderBytesSlice
} }
case pref.MessageKind: case protoreflect.MessageKind:
return getMessageInfo(ft), makeMessageSliceFieldCoder(fd, ft) return getMessageInfo(ft), makeMessageSliceFieldCoder(fd, ft)
case pref.GroupKind: case protoreflect.GroupKind:
return getMessageInfo(ft), makeGroupSliceFieldCoder(fd, ft) return getMessageInfo(ft), makeGroupSliceFieldCoder(fd, ft)
} }
case fd.Cardinality() == pref.Repeated && fd.IsPacked(): case fd.Cardinality() == protoreflect.Repeated && fd.IsPacked():
// Packed repeated fields. // Packed repeated fields.
// //
// Only repeated fields of primitive numeric types // Only repeated fields of primitive numeric types
@ -136,128 +136,128 @@ func fieldCoder(fd pref.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointer
} }
ft := ft.Elem() ft := ft.Elem()
switch fd.Kind() { switch fd.Kind() {
case pref.BoolKind: case protoreflect.BoolKind:
if ft.Kind() == reflect.Bool { if ft.Kind() == reflect.Bool {
return nil, coderBoolPackedSlice return nil, coderBoolPackedSlice
} }
case pref.EnumKind: case protoreflect.EnumKind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderEnumPackedSlice return nil, coderEnumPackedSlice
} }
case pref.Int32Kind: case protoreflect.Int32Kind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderInt32PackedSlice return nil, coderInt32PackedSlice
} }
case pref.Sint32Kind: case protoreflect.Sint32Kind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderSint32PackedSlice return nil, coderSint32PackedSlice
} }
case pref.Uint32Kind: case protoreflect.Uint32Kind:
if ft.Kind() == reflect.Uint32 { if ft.Kind() == reflect.Uint32 {
return nil, coderUint32PackedSlice return nil, coderUint32PackedSlice
} }
case pref.Int64Kind: case protoreflect.Int64Kind:
if ft.Kind() == reflect.Int64 { if ft.Kind() == reflect.Int64 {
return nil, coderInt64PackedSlice return nil, coderInt64PackedSlice
} }
case pref.Sint64Kind: case protoreflect.Sint64Kind:
if ft.Kind() == reflect.Int64 { if ft.Kind() == reflect.Int64 {
return nil, coderSint64PackedSlice return nil, coderSint64PackedSlice
} }
case pref.Uint64Kind: case protoreflect.Uint64Kind:
if ft.Kind() == reflect.Uint64 { if ft.Kind() == reflect.Uint64 {
return nil, coderUint64PackedSlice return nil, coderUint64PackedSlice
} }
case pref.Sfixed32Kind: case protoreflect.Sfixed32Kind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderSfixed32PackedSlice return nil, coderSfixed32PackedSlice
} }
case pref.Fixed32Kind: case protoreflect.Fixed32Kind:
if ft.Kind() == reflect.Uint32 { if ft.Kind() == reflect.Uint32 {
return nil, coderFixed32PackedSlice return nil, coderFixed32PackedSlice
} }
case pref.FloatKind: case protoreflect.FloatKind:
if ft.Kind() == reflect.Float32 { if ft.Kind() == reflect.Float32 {
return nil, coderFloatPackedSlice return nil, coderFloatPackedSlice
} }
case pref.Sfixed64Kind: case protoreflect.Sfixed64Kind:
if ft.Kind() == reflect.Int64 { if ft.Kind() == reflect.Int64 {
return nil, coderSfixed64PackedSlice return nil, coderSfixed64PackedSlice
} }
case pref.Fixed64Kind: case protoreflect.Fixed64Kind:
if ft.Kind() == reflect.Uint64 { if ft.Kind() == reflect.Uint64 {
return nil, coderFixed64PackedSlice return nil, coderFixed64PackedSlice
} }
case pref.DoubleKind: case protoreflect.DoubleKind:
if ft.Kind() == reflect.Float64 { if ft.Kind() == reflect.Float64 {
return nil, coderDoublePackedSlice return nil, coderDoublePackedSlice
} }
} }
case fd.Kind() == pref.MessageKind: case fd.Kind() == protoreflect.MessageKind:
return getMessageInfo(ft), makeMessageFieldCoder(fd, ft) return getMessageInfo(ft), makeMessageFieldCoder(fd, ft)
case fd.Kind() == pref.GroupKind: case fd.Kind() == protoreflect.GroupKind:
return getMessageInfo(ft), makeGroupFieldCoder(fd, ft) return getMessageInfo(ft), makeGroupFieldCoder(fd, ft)
case fd.Syntax() == pref.Proto3 && fd.ContainingOneof() == nil: case fd.Syntax() == protoreflect.Proto3 && fd.ContainingOneof() == nil:
// Populated oneof fields always encode even if set to the zero value, // Populated oneof fields always encode even if set to the zero value,
// which normally are not encoded in proto3. // which normally are not encoded in proto3.
switch fd.Kind() { switch fd.Kind() {
case pref.BoolKind: case protoreflect.BoolKind:
if ft.Kind() == reflect.Bool { if ft.Kind() == reflect.Bool {
return nil, coderBoolNoZero return nil, coderBoolNoZero
} }
case pref.EnumKind: case protoreflect.EnumKind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderEnumNoZero return nil, coderEnumNoZero
} }
case pref.Int32Kind: case protoreflect.Int32Kind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderInt32NoZero return nil, coderInt32NoZero
} }
case pref.Sint32Kind: case protoreflect.Sint32Kind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderSint32NoZero return nil, coderSint32NoZero
} }
case pref.Uint32Kind: case protoreflect.Uint32Kind:
if ft.Kind() == reflect.Uint32 { if ft.Kind() == reflect.Uint32 {
return nil, coderUint32NoZero return nil, coderUint32NoZero
} }
case pref.Int64Kind: case protoreflect.Int64Kind:
if ft.Kind() == reflect.Int64 { if ft.Kind() == reflect.Int64 {
return nil, coderInt64NoZero return nil, coderInt64NoZero
} }
case pref.Sint64Kind: case protoreflect.Sint64Kind:
if ft.Kind() == reflect.Int64 { if ft.Kind() == reflect.Int64 {
return nil, coderSint64NoZero return nil, coderSint64NoZero
} }
case pref.Uint64Kind: case protoreflect.Uint64Kind:
if ft.Kind() == reflect.Uint64 { if ft.Kind() == reflect.Uint64 {
return nil, coderUint64NoZero return nil, coderUint64NoZero
} }
case pref.Sfixed32Kind: case protoreflect.Sfixed32Kind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderSfixed32NoZero return nil, coderSfixed32NoZero
} }
case pref.Fixed32Kind: case protoreflect.Fixed32Kind:
if ft.Kind() == reflect.Uint32 { if ft.Kind() == reflect.Uint32 {
return nil, coderFixed32NoZero return nil, coderFixed32NoZero
} }
case pref.FloatKind: case protoreflect.FloatKind:
if ft.Kind() == reflect.Float32 { if ft.Kind() == reflect.Float32 {
return nil, coderFloatNoZero return nil, coderFloatNoZero
} }
case pref.Sfixed64Kind: case protoreflect.Sfixed64Kind:
if ft.Kind() == reflect.Int64 { if ft.Kind() == reflect.Int64 {
return nil, coderSfixed64NoZero return nil, coderSfixed64NoZero
} }
case pref.Fixed64Kind: case protoreflect.Fixed64Kind:
if ft.Kind() == reflect.Uint64 { if ft.Kind() == reflect.Uint64 {
return nil, coderFixed64NoZero return nil, coderFixed64NoZero
} }
case pref.DoubleKind: case protoreflect.DoubleKind:
if ft.Kind() == reflect.Float64 { if ft.Kind() == reflect.Float64 {
return nil, coderDoubleNoZero return nil, coderDoubleNoZero
} }
case pref.StringKind: case protoreflect.StringKind:
if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) { if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
return nil, coderStringNoZeroValidateUTF8 return nil, coderStringNoZeroValidateUTF8
} }
@ -270,7 +270,7 @@ func fieldCoder(fd pref.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointer
if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 { if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
return nil, coderBytesNoZero return nil, coderBytesNoZero
} }
case pref.BytesKind: case protoreflect.BytesKind:
if ft.Kind() == reflect.String { if ft.Kind() == reflect.String {
return nil, coderStringNoZero return nil, coderStringNoZero
} }
@ -281,133 +281,133 @@ func fieldCoder(fd pref.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointer
case ft.Kind() == reflect.Ptr: case ft.Kind() == reflect.Ptr:
ft := ft.Elem() ft := ft.Elem()
switch fd.Kind() { switch fd.Kind() {
case pref.BoolKind: case protoreflect.BoolKind:
if ft.Kind() == reflect.Bool { if ft.Kind() == reflect.Bool {
return nil, coderBoolPtr return nil, coderBoolPtr
} }
case pref.EnumKind: case protoreflect.EnumKind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderEnumPtr return nil, coderEnumPtr
} }
case pref.Int32Kind: case protoreflect.Int32Kind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderInt32Ptr return nil, coderInt32Ptr
} }
case pref.Sint32Kind: case protoreflect.Sint32Kind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderSint32Ptr return nil, coderSint32Ptr
} }
case pref.Uint32Kind: case protoreflect.Uint32Kind:
if ft.Kind() == reflect.Uint32 { if ft.Kind() == reflect.Uint32 {
return nil, coderUint32Ptr return nil, coderUint32Ptr
} }
case pref.Int64Kind: case protoreflect.Int64Kind:
if ft.Kind() == reflect.Int64 { if ft.Kind() == reflect.Int64 {
return nil, coderInt64Ptr return nil, coderInt64Ptr
} }
case pref.Sint64Kind: case protoreflect.Sint64Kind:
if ft.Kind() == reflect.Int64 { if ft.Kind() == reflect.Int64 {
return nil, coderSint64Ptr return nil, coderSint64Ptr
} }
case pref.Uint64Kind: case protoreflect.Uint64Kind:
if ft.Kind() == reflect.Uint64 { if ft.Kind() == reflect.Uint64 {
return nil, coderUint64Ptr return nil, coderUint64Ptr
} }
case pref.Sfixed32Kind: case protoreflect.Sfixed32Kind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderSfixed32Ptr return nil, coderSfixed32Ptr
} }
case pref.Fixed32Kind: case protoreflect.Fixed32Kind:
if ft.Kind() == reflect.Uint32 { if ft.Kind() == reflect.Uint32 {
return nil, coderFixed32Ptr return nil, coderFixed32Ptr
} }
case pref.FloatKind: case protoreflect.FloatKind:
if ft.Kind() == reflect.Float32 { if ft.Kind() == reflect.Float32 {
return nil, coderFloatPtr return nil, coderFloatPtr
} }
case pref.Sfixed64Kind: case protoreflect.Sfixed64Kind:
if ft.Kind() == reflect.Int64 { if ft.Kind() == reflect.Int64 {
return nil, coderSfixed64Ptr return nil, coderSfixed64Ptr
} }
case pref.Fixed64Kind: case protoreflect.Fixed64Kind:
if ft.Kind() == reflect.Uint64 { if ft.Kind() == reflect.Uint64 {
return nil, coderFixed64Ptr return nil, coderFixed64Ptr
} }
case pref.DoubleKind: case protoreflect.DoubleKind:
if ft.Kind() == reflect.Float64 { if ft.Kind() == reflect.Float64 {
return nil, coderDoublePtr return nil, coderDoublePtr
} }
case pref.StringKind: case protoreflect.StringKind:
if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) { if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
return nil, coderStringPtrValidateUTF8 return nil, coderStringPtrValidateUTF8
} }
if ft.Kind() == reflect.String { if ft.Kind() == reflect.String {
return nil, coderStringPtr return nil, coderStringPtr
} }
case pref.BytesKind: case protoreflect.BytesKind:
if ft.Kind() == reflect.String { if ft.Kind() == reflect.String {
return nil, coderStringPtr return nil, coderStringPtr
} }
} }
default: default:
switch fd.Kind() { switch fd.Kind() {
case pref.BoolKind: case protoreflect.BoolKind:
if ft.Kind() == reflect.Bool { if ft.Kind() == reflect.Bool {
return nil, coderBool return nil, coderBool
} }
case pref.EnumKind: case protoreflect.EnumKind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderEnum return nil, coderEnum
} }
case pref.Int32Kind: case protoreflect.Int32Kind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderInt32 return nil, coderInt32
} }
case pref.Sint32Kind: case protoreflect.Sint32Kind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderSint32 return nil, coderSint32
} }
case pref.Uint32Kind: case protoreflect.Uint32Kind:
if ft.Kind() == reflect.Uint32 { if ft.Kind() == reflect.Uint32 {
return nil, coderUint32 return nil, coderUint32
} }
case pref.Int64Kind: case protoreflect.Int64Kind:
if ft.Kind() == reflect.Int64 { if ft.Kind() == reflect.Int64 {
return nil, coderInt64 return nil, coderInt64
} }
case pref.Sint64Kind: case protoreflect.Sint64Kind:
if ft.Kind() == reflect.Int64 { if ft.Kind() == reflect.Int64 {
return nil, coderSint64 return nil, coderSint64
} }
case pref.Uint64Kind: case protoreflect.Uint64Kind:
if ft.Kind() == reflect.Uint64 { if ft.Kind() == reflect.Uint64 {
return nil, coderUint64 return nil, coderUint64
} }
case pref.Sfixed32Kind: case protoreflect.Sfixed32Kind:
if ft.Kind() == reflect.Int32 { if ft.Kind() == reflect.Int32 {
return nil, coderSfixed32 return nil, coderSfixed32
} }
case pref.Fixed32Kind: case protoreflect.Fixed32Kind:
if ft.Kind() == reflect.Uint32 { if ft.Kind() == reflect.Uint32 {
return nil, coderFixed32 return nil, coderFixed32
} }
case pref.FloatKind: case protoreflect.FloatKind:
if ft.Kind() == reflect.Float32 { if ft.Kind() == reflect.Float32 {
return nil, coderFloat return nil, coderFloat
} }
case pref.Sfixed64Kind: case protoreflect.Sfixed64Kind:
if ft.Kind() == reflect.Int64 { if ft.Kind() == reflect.Int64 {
return nil, coderSfixed64 return nil, coderSfixed64
} }
case pref.Fixed64Kind: case protoreflect.Fixed64Kind:
if ft.Kind() == reflect.Uint64 { if ft.Kind() == reflect.Uint64 {
return nil, coderFixed64 return nil, coderFixed64
} }
case pref.DoubleKind: case protoreflect.DoubleKind:
if ft.Kind() == reflect.Float64 { if ft.Kind() == reflect.Float64 {
return nil, coderDouble return nil, coderDouble
} }
case pref.StringKind: case protoreflect.StringKind:
if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) { if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
return nil, coderStringValidateUTF8 return nil, coderStringValidateUTF8
} }
@ -420,7 +420,7 @@ func fieldCoder(fd pref.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointer
if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 { if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
return nil, coderBytes return nil, coderBytes
} }
case pref.BytesKind: case protoreflect.BytesKind:
if ft.Kind() == reflect.String { if ft.Kind() == reflect.String {
return nil, coderString return nil, coderString
} }
@ -434,122 +434,122 @@ func fieldCoder(fd pref.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointer
// encoderFuncsForValue returns value functions for a field, used for // encoderFuncsForValue returns value functions for a field, used for
// extension values and map encoding. // extension values and map encoding.
func encoderFuncsForValue(fd pref.FieldDescriptor) valueCoderFuncs { func encoderFuncsForValue(fd protoreflect.FieldDescriptor) valueCoderFuncs {
switch { switch {
case fd.Cardinality() == pref.Repeated && !fd.IsPacked(): case fd.Cardinality() == protoreflect.Repeated && !fd.IsPacked():
switch fd.Kind() { switch fd.Kind() {
case pref.BoolKind: case protoreflect.BoolKind:
return coderBoolSliceValue return coderBoolSliceValue
case pref.EnumKind: case protoreflect.EnumKind:
return coderEnumSliceValue return coderEnumSliceValue
case pref.Int32Kind: case protoreflect.Int32Kind:
return coderInt32SliceValue return coderInt32SliceValue
case pref.Sint32Kind: case protoreflect.Sint32Kind:
return coderSint32SliceValue return coderSint32SliceValue
case pref.Uint32Kind: case protoreflect.Uint32Kind:
return coderUint32SliceValue return coderUint32SliceValue
case pref.Int64Kind: case protoreflect.Int64Kind:
return coderInt64SliceValue return coderInt64SliceValue
case pref.Sint64Kind: case protoreflect.Sint64Kind:
return coderSint64SliceValue return coderSint64SliceValue
case pref.Uint64Kind: case protoreflect.Uint64Kind:
return coderUint64SliceValue return coderUint64SliceValue
case pref.Sfixed32Kind: case protoreflect.Sfixed32Kind:
return coderSfixed32SliceValue return coderSfixed32SliceValue
case pref.Fixed32Kind: case protoreflect.Fixed32Kind:
return coderFixed32SliceValue return coderFixed32SliceValue
case pref.FloatKind: case protoreflect.FloatKind:
return coderFloatSliceValue return coderFloatSliceValue
case pref.Sfixed64Kind: case protoreflect.Sfixed64Kind:
return coderSfixed64SliceValue return coderSfixed64SliceValue
case pref.Fixed64Kind: case protoreflect.Fixed64Kind:
return coderFixed64SliceValue return coderFixed64SliceValue
case pref.DoubleKind: case protoreflect.DoubleKind:
return coderDoubleSliceValue return coderDoubleSliceValue
case pref.StringKind: case protoreflect.StringKind:
// We don't have a UTF-8 validating coder for repeated string fields. // We don't have a UTF-8 validating coder for repeated string fields.
// Value coders are used for extensions and maps. // Value coders are used for extensions and maps.
// Extensions are never proto3, and maps never contain lists. // Extensions are never proto3, and maps never contain lists.
return coderStringSliceValue return coderStringSliceValue
case pref.BytesKind: case protoreflect.BytesKind:
return coderBytesSliceValue return coderBytesSliceValue
case pref.MessageKind: case protoreflect.MessageKind:
return coderMessageSliceValue return coderMessageSliceValue
case pref.GroupKind: case protoreflect.GroupKind:
return coderGroupSliceValue return coderGroupSliceValue
} }
case fd.Cardinality() == pref.Repeated && fd.IsPacked(): case fd.Cardinality() == protoreflect.Repeated && fd.IsPacked():
switch fd.Kind() { switch fd.Kind() {
case pref.BoolKind: case protoreflect.BoolKind:
return coderBoolPackedSliceValue return coderBoolPackedSliceValue
case pref.EnumKind: case protoreflect.EnumKind:
return coderEnumPackedSliceValue return coderEnumPackedSliceValue
case pref.Int32Kind: case protoreflect.Int32Kind:
return coderInt32PackedSliceValue return coderInt32PackedSliceValue
case pref.Sint32Kind: case protoreflect.Sint32Kind:
return coderSint32PackedSliceValue return coderSint32PackedSliceValue
case pref.Uint32Kind: case protoreflect.Uint32Kind:
return coderUint32PackedSliceValue return coderUint32PackedSliceValue
case pref.Int64Kind: case protoreflect.Int64Kind:
return coderInt64PackedSliceValue return coderInt64PackedSliceValue
case pref.Sint64Kind: case protoreflect.Sint64Kind:
return coderSint64PackedSliceValue return coderSint64PackedSliceValue
case pref.Uint64Kind: case protoreflect.Uint64Kind:
return coderUint64PackedSliceValue return coderUint64PackedSliceValue
case pref.Sfixed32Kind: case protoreflect.Sfixed32Kind:
return coderSfixed32PackedSliceValue return coderSfixed32PackedSliceValue
case pref.Fixed32Kind: case protoreflect.Fixed32Kind:
return coderFixed32PackedSliceValue return coderFixed32PackedSliceValue
case pref.FloatKind: case protoreflect.FloatKind:
return coderFloatPackedSliceValue return coderFloatPackedSliceValue
case pref.Sfixed64Kind: case protoreflect.Sfixed64Kind:
return coderSfixed64PackedSliceValue return coderSfixed64PackedSliceValue
case pref.Fixed64Kind: case protoreflect.Fixed64Kind:
return coderFixed64PackedSliceValue return coderFixed64PackedSliceValue
case pref.DoubleKind: case protoreflect.DoubleKind:
return coderDoublePackedSliceValue return coderDoublePackedSliceValue
} }
default: default:
switch fd.Kind() { switch fd.Kind() {
default: default:
case pref.BoolKind: case protoreflect.BoolKind:
return coderBoolValue return coderBoolValue
case pref.EnumKind: case protoreflect.EnumKind:
return coderEnumValue return coderEnumValue
case pref.Int32Kind: case protoreflect.Int32Kind:
return coderInt32Value return coderInt32Value
case pref.Sint32Kind: case protoreflect.Sint32Kind:
return coderSint32Value return coderSint32Value
case pref.Uint32Kind: case protoreflect.Uint32Kind:
return coderUint32Value return coderUint32Value
case pref.Int64Kind: case protoreflect.Int64Kind:
return coderInt64Value return coderInt64Value
case pref.Sint64Kind: case protoreflect.Sint64Kind:
return coderSint64Value return coderSint64Value
case pref.Uint64Kind: case protoreflect.Uint64Kind:
return coderUint64Value return coderUint64Value
case pref.Sfixed32Kind: case protoreflect.Sfixed32Kind:
return coderSfixed32Value return coderSfixed32Value
case pref.Fixed32Kind: case protoreflect.Fixed32Kind:
return coderFixed32Value return coderFixed32Value
case pref.FloatKind: case protoreflect.FloatKind:
return coderFloatValue return coderFloatValue
case pref.Sfixed64Kind: case protoreflect.Sfixed64Kind:
return coderSfixed64Value return coderSfixed64Value
case pref.Fixed64Kind: case protoreflect.Fixed64Kind:
return coderFixed64Value return coderFixed64Value
case pref.DoubleKind: case protoreflect.DoubleKind:
return coderDoubleValue return coderDoubleValue
case pref.StringKind: case protoreflect.StringKind:
if strs.EnforceUTF8(fd) { if strs.EnforceUTF8(fd) {
return coderStringValueValidateUTF8 return coderStringValueValidateUTF8
} }
return coderStringValue return coderStringValue
case pref.BytesKind: case protoreflect.BytesKind:
return coderBytesValue return coderBytesValue
case pref.MessageKind: case protoreflect.MessageKind:
return coderMessageValue return coderMessageValue
case pref.GroupKind: case protoreflect.GroupKind:
return coderGroupValue return coderGroupValue
} }
} }

View File

@ -8,7 +8,7 @@ import (
"fmt" "fmt"
"reflect" "reflect"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
// unwrapper unwraps the value to the underlying value. // unwrapper unwraps the value to the underlying value.
@ -20,13 +20,13 @@ type unwrapper interface {
// A Converter coverts to/from Go reflect.Value types and protobuf protoreflect.Value types. // A Converter coverts to/from Go reflect.Value types and protobuf protoreflect.Value types.
type Converter interface { type Converter interface {
// PBValueOf converts a reflect.Value to a protoreflect.Value. // PBValueOf converts a reflect.Value to a protoreflect.Value.
PBValueOf(reflect.Value) pref.Value PBValueOf(reflect.Value) protoreflect.Value
// GoValueOf converts a protoreflect.Value to a reflect.Value. // GoValueOf converts a protoreflect.Value to a reflect.Value.
GoValueOf(pref.Value) reflect.Value GoValueOf(protoreflect.Value) reflect.Value
// IsValidPB returns whether a protoreflect.Value is compatible with this type. // IsValidPB returns whether a protoreflect.Value is compatible with this type.
IsValidPB(pref.Value) bool IsValidPB(protoreflect.Value) bool
// IsValidGo returns whether a reflect.Value is compatible with this type. // IsValidGo returns whether a reflect.Value is compatible with this type.
IsValidGo(reflect.Value) bool IsValidGo(reflect.Value) bool
@ -34,12 +34,12 @@ type Converter interface {
// New returns a new field value. // New returns a new field value.
// For scalars, it returns the default value of the field. // For scalars, it returns the default value of the field.
// For composite types, it returns a new mutable value. // For composite types, it returns a new mutable value.
New() pref.Value New() protoreflect.Value
// Zero returns a new field value. // Zero returns a new field value.
// For scalars, it returns the default value of the field. // For scalars, it returns the default value of the field.
// For composite types, it returns an immutable, empty value. // For composite types, it returns an immutable, empty value.
Zero() pref.Value Zero() protoreflect.Value
} }
// NewConverter matches a Go type with a protobuf field and returns a Converter // NewConverter matches a Go type with a protobuf field and returns a Converter
@ -50,7 +50,7 @@ type Converter interface {
// This matcher deliberately supports a wider range of Go types than what // This matcher deliberately supports a wider range of Go types than what
// protoc-gen-go historically generated to be able to automatically wrap some // protoc-gen-go historically generated to be able to automatically wrap some
// v1 messages generated by other forks of protoc-gen-go. // v1 messages generated by other forks of protoc-gen-go.
func NewConverter(t reflect.Type, fd pref.FieldDescriptor) Converter { func NewConverter(t reflect.Type, fd protoreflect.FieldDescriptor) Converter {
switch { switch {
case fd.IsList(): case fd.IsList():
return newListConverter(t, fd) return newListConverter(t, fd)
@ -76,68 +76,68 @@ var (
) )
var ( var (
boolZero = pref.ValueOfBool(false) boolZero = protoreflect.ValueOfBool(false)
int32Zero = pref.ValueOfInt32(0) int32Zero = protoreflect.ValueOfInt32(0)
int64Zero = pref.ValueOfInt64(0) int64Zero = protoreflect.ValueOfInt64(0)
uint32Zero = pref.ValueOfUint32(0) uint32Zero = protoreflect.ValueOfUint32(0)
uint64Zero = pref.ValueOfUint64(0) uint64Zero = protoreflect.ValueOfUint64(0)
float32Zero = pref.ValueOfFloat32(0) float32Zero = protoreflect.ValueOfFloat32(0)
float64Zero = pref.ValueOfFloat64(0) float64Zero = protoreflect.ValueOfFloat64(0)
stringZero = pref.ValueOfString("") stringZero = protoreflect.ValueOfString("")
bytesZero = pref.ValueOfBytes(nil) bytesZero = protoreflect.ValueOfBytes(nil)
) )
func newSingularConverter(t reflect.Type, fd pref.FieldDescriptor) Converter { func newSingularConverter(t reflect.Type, fd protoreflect.FieldDescriptor) Converter {
defVal := func(fd pref.FieldDescriptor, zero pref.Value) pref.Value { defVal := func(fd protoreflect.FieldDescriptor, zero protoreflect.Value) protoreflect.Value {
if fd.Cardinality() == pref.Repeated { if fd.Cardinality() == protoreflect.Repeated {
// Default isn't defined for repeated fields. // Default isn't defined for repeated fields.
return zero return zero
} }
return fd.Default() return fd.Default()
} }
switch fd.Kind() { switch fd.Kind() {
case pref.BoolKind: case protoreflect.BoolKind:
if t.Kind() == reflect.Bool { if t.Kind() == reflect.Bool {
return &boolConverter{t, defVal(fd, boolZero)} return &boolConverter{t, defVal(fd, boolZero)}
} }
case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind: case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
if t.Kind() == reflect.Int32 { if t.Kind() == reflect.Int32 {
return &int32Converter{t, defVal(fd, int32Zero)} return &int32Converter{t, defVal(fd, int32Zero)}
} }
case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind: case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
if t.Kind() == reflect.Int64 { if t.Kind() == reflect.Int64 {
return &int64Converter{t, defVal(fd, int64Zero)} return &int64Converter{t, defVal(fd, int64Zero)}
} }
case pref.Uint32Kind, pref.Fixed32Kind: case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
if t.Kind() == reflect.Uint32 { if t.Kind() == reflect.Uint32 {
return &uint32Converter{t, defVal(fd, uint32Zero)} return &uint32Converter{t, defVal(fd, uint32Zero)}
} }
case pref.Uint64Kind, pref.Fixed64Kind: case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
if t.Kind() == reflect.Uint64 { if t.Kind() == reflect.Uint64 {
return &uint64Converter{t, defVal(fd, uint64Zero)} return &uint64Converter{t, defVal(fd, uint64Zero)}
} }
case pref.FloatKind: case protoreflect.FloatKind:
if t.Kind() == reflect.Float32 { if t.Kind() == reflect.Float32 {
return &float32Converter{t, defVal(fd, float32Zero)} return &float32Converter{t, defVal(fd, float32Zero)}
} }
case pref.DoubleKind: case protoreflect.DoubleKind:
if t.Kind() == reflect.Float64 { if t.Kind() == reflect.Float64 {
return &float64Converter{t, defVal(fd, float64Zero)} return &float64Converter{t, defVal(fd, float64Zero)}
} }
case pref.StringKind: case protoreflect.StringKind:
if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) { if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
return &stringConverter{t, defVal(fd, stringZero)} return &stringConverter{t, defVal(fd, stringZero)}
} }
case pref.BytesKind: case protoreflect.BytesKind:
if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) { if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
return &bytesConverter{t, defVal(fd, bytesZero)} return &bytesConverter{t, defVal(fd, bytesZero)}
} }
case pref.EnumKind: case protoreflect.EnumKind:
// Handle enums, which must be a named int32 type. // Handle enums, which must be a named int32 type.
if t.Kind() == reflect.Int32 { if t.Kind() == reflect.Int32 {
return newEnumConverter(t, fd) return newEnumConverter(t, fd)
} }
case pref.MessageKind, pref.GroupKind: case protoreflect.MessageKind, protoreflect.GroupKind:
return newMessageConverter(t) return newMessageConverter(t)
} }
panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName())) panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
@ -145,184 +145,184 @@ func newSingularConverter(t reflect.Type, fd pref.FieldDescriptor) Converter {
type boolConverter struct { type boolConverter struct {
goType reflect.Type goType reflect.Type
def pref.Value def protoreflect.Value
} }
func (c *boolConverter) PBValueOf(v reflect.Value) pref.Value { func (c *boolConverter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType { if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType)) panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
} }
return pref.ValueOfBool(v.Bool()) return protoreflect.ValueOfBool(v.Bool())
} }
func (c *boolConverter) GoValueOf(v pref.Value) reflect.Value { func (c *boolConverter) GoValueOf(v protoreflect.Value) reflect.Value {
return reflect.ValueOf(v.Bool()).Convert(c.goType) return reflect.ValueOf(v.Bool()).Convert(c.goType)
} }
func (c *boolConverter) IsValidPB(v pref.Value) bool { func (c *boolConverter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().(bool) _, ok := v.Interface().(bool)
return ok return ok
} }
func (c *boolConverter) IsValidGo(v reflect.Value) bool { func (c *boolConverter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType return v.IsValid() && v.Type() == c.goType
} }
func (c *boolConverter) New() pref.Value { return c.def } func (c *boolConverter) New() protoreflect.Value { return c.def }
func (c *boolConverter) Zero() pref.Value { return c.def } func (c *boolConverter) Zero() protoreflect.Value { return c.def }
type int32Converter struct { type int32Converter struct {
goType reflect.Type goType reflect.Type
def pref.Value def protoreflect.Value
} }
func (c *int32Converter) PBValueOf(v reflect.Value) pref.Value { func (c *int32Converter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType { if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType)) panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
} }
return pref.ValueOfInt32(int32(v.Int())) return protoreflect.ValueOfInt32(int32(v.Int()))
} }
func (c *int32Converter) GoValueOf(v pref.Value) reflect.Value { func (c *int32Converter) GoValueOf(v protoreflect.Value) reflect.Value {
return reflect.ValueOf(int32(v.Int())).Convert(c.goType) return reflect.ValueOf(int32(v.Int())).Convert(c.goType)
} }
func (c *int32Converter) IsValidPB(v pref.Value) bool { func (c *int32Converter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().(int32) _, ok := v.Interface().(int32)
return ok return ok
} }
func (c *int32Converter) IsValidGo(v reflect.Value) bool { func (c *int32Converter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType return v.IsValid() && v.Type() == c.goType
} }
func (c *int32Converter) New() pref.Value { return c.def } func (c *int32Converter) New() protoreflect.Value { return c.def }
func (c *int32Converter) Zero() pref.Value { return c.def } func (c *int32Converter) Zero() protoreflect.Value { return c.def }
type int64Converter struct { type int64Converter struct {
goType reflect.Type goType reflect.Type
def pref.Value def protoreflect.Value
} }
func (c *int64Converter) PBValueOf(v reflect.Value) pref.Value { func (c *int64Converter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType { if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType)) panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
} }
return pref.ValueOfInt64(int64(v.Int())) return protoreflect.ValueOfInt64(int64(v.Int()))
} }
func (c *int64Converter) GoValueOf(v pref.Value) reflect.Value { func (c *int64Converter) GoValueOf(v protoreflect.Value) reflect.Value {
return reflect.ValueOf(int64(v.Int())).Convert(c.goType) return reflect.ValueOf(int64(v.Int())).Convert(c.goType)
} }
func (c *int64Converter) IsValidPB(v pref.Value) bool { func (c *int64Converter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().(int64) _, ok := v.Interface().(int64)
return ok return ok
} }
func (c *int64Converter) IsValidGo(v reflect.Value) bool { func (c *int64Converter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType return v.IsValid() && v.Type() == c.goType
} }
func (c *int64Converter) New() pref.Value { return c.def } func (c *int64Converter) New() protoreflect.Value { return c.def }
func (c *int64Converter) Zero() pref.Value { return c.def } func (c *int64Converter) Zero() protoreflect.Value { return c.def }
type uint32Converter struct { type uint32Converter struct {
goType reflect.Type goType reflect.Type
def pref.Value def protoreflect.Value
} }
func (c *uint32Converter) PBValueOf(v reflect.Value) pref.Value { func (c *uint32Converter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType { if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType)) panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
} }
return pref.ValueOfUint32(uint32(v.Uint())) return protoreflect.ValueOfUint32(uint32(v.Uint()))
} }
func (c *uint32Converter) GoValueOf(v pref.Value) reflect.Value { func (c *uint32Converter) GoValueOf(v protoreflect.Value) reflect.Value {
return reflect.ValueOf(uint32(v.Uint())).Convert(c.goType) return reflect.ValueOf(uint32(v.Uint())).Convert(c.goType)
} }
func (c *uint32Converter) IsValidPB(v pref.Value) bool { func (c *uint32Converter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().(uint32) _, ok := v.Interface().(uint32)
return ok return ok
} }
func (c *uint32Converter) IsValidGo(v reflect.Value) bool { func (c *uint32Converter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType return v.IsValid() && v.Type() == c.goType
} }
func (c *uint32Converter) New() pref.Value { return c.def } func (c *uint32Converter) New() protoreflect.Value { return c.def }
func (c *uint32Converter) Zero() pref.Value { return c.def } func (c *uint32Converter) Zero() protoreflect.Value { return c.def }
type uint64Converter struct { type uint64Converter struct {
goType reflect.Type goType reflect.Type
def pref.Value def protoreflect.Value
} }
func (c *uint64Converter) PBValueOf(v reflect.Value) pref.Value { func (c *uint64Converter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType { if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType)) panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
} }
return pref.ValueOfUint64(uint64(v.Uint())) return protoreflect.ValueOfUint64(uint64(v.Uint()))
} }
func (c *uint64Converter) GoValueOf(v pref.Value) reflect.Value { func (c *uint64Converter) GoValueOf(v protoreflect.Value) reflect.Value {
return reflect.ValueOf(uint64(v.Uint())).Convert(c.goType) return reflect.ValueOf(uint64(v.Uint())).Convert(c.goType)
} }
func (c *uint64Converter) IsValidPB(v pref.Value) bool { func (c *uint64Converter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().(uint64) _, ok := v.Interface().(uint64)
return ok return ok
} }
func (c *uint64Converter) IsValidGo(v reflect.Value) bool { func (c *uint64Converter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType return v.IsValid() && v.Type() == c.goType
} }
func (c *uint64Converter) New() pref.Value { return c.def } func (c *uint64Converter) New() protoreflect.Value { return c.def }
func (c *uint64Converter) Zero() pref.Value { return c.def } func (c *uint64Converter) Zero() protoreflect.Value { return c.def }
type float32Converter struct { type float32Converter struct {
goType reflect.Type goType reflect.Type
def pref.Value def protoreflect.Value
} }
func (c *float32Converter) PBValueOf(v reflect.Value) pref.Value { func (c *float32Converter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType { if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType)) panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
} }
return pref.ValueOfFloat32(float32(v.Float())) return protoreflect.ValueOfFloat32(float32(v.Float()))
} }
func (c *float32Converter) GoValueOf(v pref.Value) reflect.Value { func (c *float32Converter) GoValueOf(v protoreflect.Value) reflect.Value {
return reflect.ValueOf(float32(v.Float())).Convert(c.goType) return reflect.ValueOf(float32(v.Float())).Convert(c.goType)
} }
func (c *float32Converter) IsValidPB(v pref.Value) bool { func (c *float32Converter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().(float32) _, ok := v.Interface().(float32)
return ok return ok
} }
func (c *float32Converter) IsValidGo(v reflect.Value) bool { func (c *float32Converter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType return v.IsValid() && v.Type() == c.goType
} }
func (c *float32Converter) New() pref.Value { return c.def } func (c *float32Converter) New() protoreflect.Value { return c.def }
func (c *float32Converter) Zero() pref.Value { return c.def } func (c *float32Converter) Zero() protoreflect.Value { return c.def }
type float64Converter struct { type float64Converter struct {
goType reflect.Type goType reflect.Type
def pref.Value def protoreflect.Value
} }
func (c *float64Converter) PBValueOf(v reflect.Value) pref.Value { func (c *float64Converter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType { if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType)) panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
} }
return pref.ValueOfFloat64(float64(v.Float())) return protoreflect.ValueOfFloat64(float64(v.Float()))
} }
func (c *float64Converter) GoValueOf(v pref.Value) reflect.Value { func (c *float64Converter) GoValueOf(v protoreflect.Value) reflect.Value {
return reflect.ValueOf(float64(v.Float())).Convert(c.goType) return reflect.ValueOf(float64(v.Float())).Convert(c.goType)
} }
func (c *float64Converter) IsValidPB(v pref.Value) bool { func (c *float64Converter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().(float64) _, ok := v.Interface().(float64)
return ok return ok
} }
func (c *float64Converter) IsValidGo(v reflect.Value) bool { func (c *float64Converter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType return v.IsValid() && v.Type() == c.goType
} }
func (c *float64Converter) New() pref.Value { return c.def } func (c *float64Converter) New() protoreflect.Value { return c.def }
func (c *float64Converter) Zero() pref.Value { return c.def } func (c *float64Converter) Zero() protoreflect.Value { return c.def }
type stringConverter struct { type stringConverter struct {
goType reflect.Type goType reflect.Type
def pref.Value def protoreflect.Value
} }
func (c *stringConverter) PBValueOf(v reflect.Value) pref.Value { func (c *stringConverter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType { if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType)) panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
} }
return pref.ValueOfString(v.Convert(stringType).String()) return protoreflect.ValueOfString(v.Convert(stringType).String())
} }
func (c *stringConverter) GoValueOf(v pref.Value) reflect.Value { func (c *stringConverter) GoValueOf(v protoreflect.Value) reflect.Value {
// pref.Value.String never panics, so we go through an interface // pref.Value.String never panics, so we go through an interface
// conversion here to check the type. // conversion here to check the type.
s := v.Interface().(string) s := v.Interface().(string)
@ -331,71 +331,71 @@ func (c *stringConverter) GoValueOf(v pref.Value) reflect.Value {
} }
return reflect.ValueOf(s).Convert(c.goType) return reflect.ValueOf(s).Convert(c.goType)
} }
func (c *stringConverter) IsValidPB(v pref.Value) bool { func (c *stringConverter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().(string) _, ok := v.Interface().(string)
return ok return ok
} }
func (c *stringConverter) IsValidGo(v reflect.Value) bool { func (c *stringConverter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType return v.IsValid() && v.Type() == c.goType
} }
func (c *stringConverter) New() pref.Value { return c.def } func (c *stringConverter) New() protoreflect.Value { return c.def }
func (c *stringConverter) Zero() pref.Value { return c.def } func (c *stringConverter) Zero() protoreflect.Value { return c.def }
type bytesConverter struct { type bytesConverter struct {
goType reflect.Type goType reflect.Type
def pref.Value def protoreflect.Value
} }
func (c *bytesConverter) PBValueOf(v reflect.Value) pref.Value { func (c *bytesConverter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType { if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType)) panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
} }
if c.goType.Kind() == reflect.String && v.Len() == 0 { if c.goType.Kind() == reflect.String && v.Len() == 0 {
return pref.ValueOfBytes(nil) // ensure empty string is []byte(nil) return protoreflect.ValueOfBytes(nil) // ensure empty string is []byte(nil)
} }
return pref.ValueOfBytes(v.Convert(bytesType).Bytes()) return protoreflect.ValueOfBytes(v.Convert(bytesType).Bytes())
} }
func (c *bytesConverter) GoValueOf(v pref.Value) reflect.Value { func (c *bytesConverter) GoValueOf(v protoreflect.Value) reflect.Value {
return reflect.ValueOf(v.Bytes()).Convert(c.goType) return reflect.ValueOf(v.Bytes()).Convert(c.goType)
} }
func (c *bytesConverter) IsValidPB(v pref.Value) bool { func (c *bytesConverter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().([]byte) _, ok := v.Interface().([]byte)
return ok return ok
} }
func (c *bytesConverter) IsValidGo(v reflect.Value) bool { func (c *bytesConverter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType return v.IsValid() && v.Type() == c.goType
} }
func (c *bytesConverter) New() pref.Value { return c.def } func (c *bytesConverter) New() protoreflect.Value { return c.def }
func (c *bytesConverter) Zero() pref.Value { return c.def } func (c *bytesConverter) Zero() protoreflect.Value { return c.def }
type enumConverter struct { type enumConverter struct {
goType reflect.Type goType reflect.Type
def pref.Value def protoreflect.Value
} }
func newEnumConverter(goType reflect.Type, fd pref.FieldDescriptor) Converter { func newEnumConverter(goType reflect.Type, fd protoreflect.FieldDescriptor) Converter {
var def pref.Value var def protoreflect.Value
if fd.Cardinality() == pref.Repeated { if fd.Cardinality() == protoreflect.Repeated {
def = pref.ValueOfEnum(fd.Enum().Values().Get(0).Number()) def = protoreflect.ValueOfEnum(fd.Enum().Values().Get(0).Number())
} else { } else {
def = fd.Default() def = fd.Default()
} }
return &enumConverter{goType, def} return &enumConverter{goType, def}
} }
func (c *enumConverter) PBValueOf(v reflect.Value) pref.Value { func (c *enumConverter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType { if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType)) panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
} }
return pref.ValueOfEnum(pref.EnumNumber(v.Int())) return protoreflect.ValueOfEnum(protoreflect.EnumNumber(v.Int()))
} }
func (c *enumConverter) GoValueOf(v pref.Value) reflect.Value { func (c *enumConverter) GoValueOf(v protoreflect.Value) reflect.Value {
return reflect.ValueOf(v.Enum()).Convert(c.goType) return reflect.ValueOf(v.Enum()).Convert(c.goType)
} }
func (c *enumConverter) IsValidPB(v pref.Value) bool { func (c *enumConverter) IsValidPB(v protoreflect.Value) bool {
_, ok := v.Interface().(pref.EnumNumber) _, ok := v.Interface().(protoreflect.EnumNumber)
return ok return ok
} }
@ -403,11 +403,11 @@ func (c *enumConverter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType return v.IsValid() && v.Type() == c.goType
} }
func (c *enumConverter) New() pref.Value { func (c *enumConverter) New() protoreflect.Value {
return c.def return c.def
} }
func (c *enumConverter) Zero() pref.Value { func (c *enumConverter) Zero() protoreflect.Value {
return c.def return c.def
} }
@ -419,7 +419,7 @@ func newMessageConverter(goType reflect.Type) Converter {
return &messageConverter{goType} return &messageConverter{goType}
} }
func (c *messageConverter) PBValueOf(v reflect.Value) pref.Value { func (c *messageConverter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType { if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType)) panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
} }
@ -430,13 +430,13 @@ func (c *messageConverter) PBValueOf(v reflect.Value) pref.Value {
v = reflect.Zero(reflect.PtrTo(v.Type())) v = reflect.Zero(reflect.PtrTo(v.Type()))
} }
} }
if m, ok := v.Interface().(pref.ProtoMessage); ok { if m, ok := v.Interface().(protoreflect.ProtoMessage); ok {
return pref.ValueOfMessage(m.ProtoReflect()) return protoreflect.ValueOfMessage(m.ProtoReflect())
} }
return pref.ValueOfMessage(legacyWrapMessage(v)) return protoreflect.ValueOfMessage(legacyWrapMessage(v))
} }
func (c *messageConverter) GoValueOf(v pref.Value) reflect.Value { func (c *messageConverter) GoValueOf(v protoreflect.Value) reflect.Value {
m := v.Message() m := v.Message()
var rv reflect.Value var rv reflect.Value
if u, ok := m.(unwrapper); ok { if u, ok := m.(unwrapper); ok {
@ -460,7 +460,7 @@ func (c *messageConverter) GoValueOf(v pref.Value) reflect.Value {
return rv return rv
} }
func (c *messageConverter) IsValidPB(v pref.Value) bool { func (c *messageConverter) IsValidPB(v protoreflect.Value) bool {
m := v.Message() m := v.Message()
var rv reflect.Value var rv reflect.Value
if u, ok := m.(unwrapper); ok { if u, ok := m.(unwrapper); ok {
@ -478,14 +478,14 @@ func (c *messageConverter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType return v.IsValid() && v.Type() == c.goType
} }
func (c *messageConverter) New() pref.Value { func (c *messageConverter) New() protoreflect.Value {
if c.isNonPointer() { if c.isNonPointer() {
return c.PBValueOf(reflect.New(c.goType).Elem()) return c.PBValueOf(reflect.New(c.goType).Elem())
} }
return c.PBValueOf(reflect.New(c.goType.Elem())) return c.PBValueOf(reflect.New(c.goType.Elem()))
} }
func (c *messageConverter) Zero() pref.Value { func (c *messageConverter) Zero() protoreflect.Value {
return c.PBValueOf(reflect.Zero(c.goType)) return c.PBValueOf(reflect.Zero(c.goType))
} }

View File

@ -8,10 +8,10 @@ import (
"fmt" "fmt"
"reflect" "reflect"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
func newListConverter(t reflect.Type, fd pref.FieldDescriptor) Converter { func newListConverter(t reflect.Type, fd protoreflect.FieldDescriptor) Converter {
switch { switch {
case t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Slice: case t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Slice:
return &listPtrConverter{t, newSingularConverter(t.Elem().Elem(), fd)} return &listPtrConverter{t, newSingularConverter(t.Elem().Elem(), fd)}
@ -26,16 +26,16 @@ type listConverter struct {
c Converter c Converter
} }
func (c *listConverter) PBValueOf(v reflect.Value) pref.Value { func (c *listConverter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType { if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType)) panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
} }
pv := reflect.New(c.goType) pv := reflect.New(c.goType)
pv.Elem().Set(v) pv.Elem().Set(v)
return pref.ValueOfList(&listReflect{pv, c.c}) return protoreflect.ValueOfList(&listReflect{pv, c.c})
} }
func (c *listConverter) GoValueOf(v pref.Value) reflect.Value { func (c *listConverter) GoValueOf(v protoreflect.Value) reflect.Value {
rv := v.List().(*listReflect).v rv := v.List().(*listReflect).v
if rv.IsNil() { if rv.IsNil() {
return reflect.Zero(c.goType) return reflect.Zero(c.goType)
@ -43,7 +43,7 @@ func (c *listConverter) GoValueOf(v pref.Value) reflect.Value {
return rv.Elem() return rv.Elem()
} }
func (c *listConverter) IsValidPB(v pref.Value) bool { func (c *listConverter) IsValidPB(v protoreflect.Value) bool {
list, ok := v.Interface().(*listReflect) list, ok := v.Interface().(*listReflect)
if !ok { if !ok {
return false return false
@ -55,12 +55,12 @@ func (c *listConverter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType return v.IsValid() && v.Type() == c.goType
} }
func (c *listConverter) New() pref.Value { func (c *listConverter) New() protoreflect.Value {
return pref.ValueOfList(&listReflect{reflect.New(c.goType), c.c}) return protoreflect.ValueOfList(&listReflect{reflect.New(c.goType), c.c})
} }
func (c *listConverter) Zero() pref.Value { func (c *listConverter) Zero() protoreflect.Value {
return pref.ValueOfList(&listReflect{reflect.Zero(reflect.PtrTo(c.goType)), c.c}) return protoreflect.ValueOfList(&listReflect{reflect.Zero(reflect.PtrTo(c.goType)), c.c})
} }
type listPtrConverter struct { type listPtrConverter struct {
@ -68,18 +68,18 @@ type listPtrConverter struct {
c Converter c Converter
} }
func (c *listPtrConverter) PBValueOf(v reflect.Value) pref.Value { func (c *listPtrConverter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType { if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType)) panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
} }
return pref.ValueOfList(&listReflect{v, c.c}) return protoreflect.ValueOfList(&listReflect{v, c.c})
} }
func (c *listPtrConverter) GoValueOf(v pref.Value) reflect.Value { func (c *listPtrConverter) GoValueOf(v protoreflect.Value) reflect.Value {
return v.List().(*listReflect).v return v.List().(*listReflect).v
} }
func (c *listPtrConverter) IsValidPB(v pref.Value) bool { func (c *listPtrConverter) IsValidPB(v protoreflect.Value) bool {
list, ok := v.Interface().(*listReflect) list, ok := v.Interface().(*listReflect)
if !ok { if !ok {
return false return false
@ -91,11 +91,11 @@ func (c *listPtrConverter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType return v.IsValid() && v.Type() == c.goType
} }
func (c *listPtrConverter) New() pref.Value { func (c *listPtrConverter) New() protoreflect.Value {
return c.PBValueOf(reflect.New(c.goType.Elem())) return c.PBValueOf(reflect.New(c.goType.Elem()))
} }
func (c *listPtrConverter) Zero() pref.Value { func (c *listPtrConverter) Zero() protoreflect.Value {
return c.PBValueOf(reflect.Zero(c.goType)) return c.PBValueOf(reflect.Zero(c.goType))
} }
@ -110,16 +110,16 @@ func (ls *listReflect) Len() int {
} }
return ls.v.Elem().Len() return ls.v.Elem().Len()
} }
func (ls *listReflect) Get(i int) pref.Value { func (ls *listReflect) Get(i int) protoreflect.Value {
return ls.conv.PBValueOf(ls.v.Elem().Index(i)) return ls.conv.PBValueOf(ls.v.Elem().Index(i))
} }
func (ls *listReflect) Set(i int, v pref.Value) { func (ls *listReflect) Set(i int, v protoreflect.Value) {
ls.v.Elem().Index(i).Set(ls.conv.GoValueOf(v)) ls.v.Elem().Index(i).Set(ls.conv.GoValueOf(v))
} }
func (ls *listReflect) Append(v pref.Value) { func (ls *listReflect) Append(v protoreflect.Value) {
ls.v.Elem().Set(reflect.Append(ls.v.Elem(), ls.conv.GoValueOf(v))) ls.v.Elem().Set(reflect.Append(ls.v.Elem(), ls.conv.GoValueOf(v)))
} }
func (ls *listReflect) AppendMutable() pref.Value { func (ls *listReflect) AppendMutable() protoreflect.Value {
if _, ok := ls.conv.(*messageConverter); !ok { if _, ok := ls.conv.(*messageConverter); !ok {
panic("invalid AppendMutable on list with non-message type") panic("invalid AppendMutable on list with non-message type")
} }
@ -130,7 +130,7 @@ func (ls *listReflect) AppendMutable() pref.Value {
func (ls *listReflect) Truncate(i int) { func (ls *listReflect) Truncate(i int) {
ls.v.Elem().Set(ls.v.Elem().Slice(0, i)) ls.v.Elem().Set(ls.v.Elem().Slice(0, i))
} }
func (ls *listReflect) NewElement() pref.Value { func (ls *listReflect) NewElement() protoreflect.Value {
return ls.conv.New() return ls.conv.New()
} }
func (ls *listReflect) IsValid() bool { func (ls *listReflect) IsValid() bool {

View File

@ -8,7 +8,7 @@ import (
"fmt" "fmt"
"reflect" "reflect"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
type mapConverter struct { type mapConverter struct {
@ -16,7 +16,7 @@ type mapConverter struct {
keyConv, valConv Converter keyConv, valConv Converter
} }
func newMapConverter(t reflect.Type, fd pref.FieldDescriptor) *mapConverter { func newMapConverter(t reflect.Type, fd protoreflect.FieldDescriptor) *mapConverter {
if t.Kind() != reflect.Map { if t.Kind() != reflect.Map {
panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName())) panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
} }
@ -27,18 +27,18 @@ func newMapConverter(t reflect.Type, fd pref.FieldDescriptor) *mapConverter {
} }
} }
func (c *mapConverter) PBValueOf(v reflect.Value) pref.Value { func (c *mapConverter) PBValueOf(v reflect.Value) protoreflect.Value {
if v.Type() != c.goType { if v.Type() != c.goType {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType)) panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
} }
return pref.ValueOfMap(&mapReflect{v, c.keyConv, c.valConv}) return protoreflect.ValueOfMap(&mapReflect{v, c.keyConv, c.valConv})
} }
func (c *mapConverter) GoValueOf(v pref.Value) reflect.Value { func (c *mapConverter) GoValueOf(v protoreflect.Value) reflect.Value {
return v.Map().(*mapReflect).v return v.Map().(*mapReflect).v
} }
func (c *mapConverter) IsValidPB(v pref.Value) bool { func (c *mapConverter) IsValidPB(v protoreflect.Value) bool {
mapv, ok := v.Interface().(*mapReflect) mapv, ok := v.Interface().(*mapReflect)
if !ok { if !ok {
return false return false
@ -50,11 +50,11 @@ func (c *mapConverter) IsValidGo(v reflect.Value) bool {
return v.IsValid() && v.Type() == c.goType return v.IsValid() && v.Type() == c.goType
} }
func (c *mapConverter) New() pref.Value { func (c *mapConverter) New() protoreflect.Value {
return c.PBValueOf(reflect.MakeMap(c.goType)) return c.PBValueOf(reflect.MakeMap(c.goType))
} }
func (c *mapConverter) Zero() pref.Value { func (c *mapConverter) Zero() protoreflect.Value {
return c.PBValueOf(reflect.Zero(c.goType)) return c.PBValueOf(reflect.Zero(c.goType))
} }
@ -67,29 +67,29 @@ type mapReflect struct {
func (ms *mapReflect) Len() int { func (ms *mapReflect) Len() int {
return ms.v.Len() return ms.v.Len()
} }
func (ms *mapReflect) Has(k pref.MapKey) bool { func (ms *mapReflect) Has(k protoreflect.MapKey) bool {
rk := ms.keyConv.GoValueOf(k.Value()) rk := ms.keyConv.GoValueOf(k.Value())
rv := ms.v.MapIndex(rk) rv := ms.v.MapIndex(rk)
return rv.IsValid() return rv.IsValid()
} }
func (ms *mapReflect) Get(k pref.MapKey) pref.Value { func (ms *mapReflect) Get(k protoreflect.MapKey) protoreflect.Value {
rk := ms.keyConv.GoValueOf(k.Value()) rk := ms.keyConv.GoValueOf(k.Value())
rv := ms.v.MapIndex(rk) rv := ms.v.MapIndex(rk)
if !rv.IsValid() { if !rv.IsValid() {
return pref.Value{} return protoreflect.Value{}
} }
return ms.valConv.PBValueOf(rv) return ms.valConv.PBValueOf(rv)
} }
func (ms *mapReflect) Set(k pref.MapKey, v pref.Value) { func (ms *mapReflect) Set(k protoreflect.MapKey, v protoreflect.Value) {
rk := ms.keyConv.GoValueOf(k.Value()) rk := ms.keyConv.GoValueOf(k.Value())
rv := ms.valConv.GoValueOf(v) rv := ms.valConv.GoValueOf(v)
ms.v.SetMapIndex(rk, rv) ms.v.SetMapIndex(rk, rv)
} }
func (ms *mapReflect) Clear(k pref.MapKey) { func (ms *mapReflect) Clear(k protoreflect.MapKey) {
rk := ms.keyConv.GoValueOf(k.Value()) rk := ms.keyConv.GoValueOf(k.Value())
ms.v.SetMapIndex(rk, reflect.Value{}) ms.v.SetMapIndex(rk, reflect.Value{})
} }
func (ms *mapReflect) Mutable(k pref.MapKey) pref.Value { func (ms *mapReflect) Mutable(k protoreflect.MapKey) protoreflect.Value {
if _, ok := ms.valConv.(*messageConverter); !ok { if _, ok := ms.valConv.(*messageConverter); !ok {
panic("invalid Mutable on map with non-message value type") panic("invalid Mutable on map with non-message value type")
} }
@ -100,7 +100,7 @@ func (ms *mapReflect) Mutable(k pref.MapKey) pref.Value {
} }
return v return v
} }
func (ms *mapReflect) Range(f func(pref.MapKey, pref.Value) bool) { func (ms *mapReflect) Range(f func(protoreflect.MapKey, protoreflect.Value) bool) {
iter := mapRange(ms.v) iter := mapRange(ms.v)
for iter.Next() { for iter.Next() {
k := ms.keyConv.PBValueOf(iter.Key()).MapKey() k := ms.keyConv.PBValueOf(iter.Key()).MapKey()
@ -110,7 +110,7 @@ func (ms *mapReflect) Range(f func(pref.MapKey, pref.Value) bool) {
} }
} }
} }
func (ms *mapReflect) NewValue() pref.Value { func (ms *mapReflect) NewValue() protoreflect.Value {
return ms.valConv.New() return ms.valConv.New()
} }
func (ms *mapReflect) IsValid() bool { func (ms *mapReflect) IsValid() bool {

View File

@ -12,9 +12,8 @@ import (
"google.golang.org/protobuf/internal/flags" "google.golang.org/protobuf/internal/flags"
"google.golang.org/protobuf/proto" "google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
preg "google.golang.org/protobuf/reflect/protoregistry" "google.golang.org/protobuf/reflect/protoregistry"
"google.golang.org/protobuf/runtime/protoiface" "google.golang.org/protobuf/runtime/protoiface"
piface "google.golang.org/protobuf/runtime/protoiface"
) )
var errDecode = errors.New("cannot parse invalid wire-format data") var errDecode = errors.New("cannot parse invalid wire-format data")
@ -38,14 +37,16 @@ func (o unmarshalOptions) Options() proto.UnmarshalOptions {
} }
} }
func (o unmarshalOptions) DiscardUnknown() bool { return o.flags&piface.UnmarshalDiscardUnknown != 0 } func (o unmarshalOptions) DiscardUnknown() bool {
return o.flags&protoiface.UnmarshalDiscardUnknown != 0
}
func (o unmarshalOptions) IsDefault() bool { func (o unmarshalOptions) IsDefault() bool {
return o.flags == 0 && o.resolver == preg.GlobalTypes return o.flags == 0 && o.resolver == protoregistry.GlobalTypes
} }
var lazyUnmarshalOptions = unmarshalOptions{ var lazyUnmarshalOptions = unmarshalOptions{
resolver: preg.GlobalTypes, resolver: protoregistry.GlobalTypes,
depth: protowire.DefaultRecursionLimit, depth: protowire.DefaultRecursionLimit,
} }
@ -55,7 +56,7 @@ type unmarshalOutput struct {
} }
// unmarshal is protoreflect.Methods.Unmarshal. // unmarshal is protoreflect.Methods.Unmarshal.
func (mi *MessageInfo) unmarshal(in piface.UnmarshalInput) (piface.UnmarshalOutput, error) { func (mi *MessageInfo) unmarshal(in protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
var p pointer var p pointer
if ms, ok := in.Message.(*messageState); ok { if ms, ok := in.Message.(*messageState); ok {
p = ms.pointer() p = ms.pointer()
@ -67,11 +68,11 @@ func (mi *MessageInfo) unmarshal(in piface.UnmarshalInput) (piface.UnmarshalOutp
resolver: in.Resolver, resolver: in.Resolver,
depth: in.Depth, depth: in.Depth,
}) })
var flags piface.UnmarshalOutputFlags var flags protoiface.UnmarshalOutputFlags
if out.initialized { if out.initialized {
flags |= piface.UnmarshalInitialized flags |= protoiface.UnmarshalInitialized
} }
return piface.UnmarshalOutput{ return protoiface.UnmarshalOutput{
Flags: flags, Flags: flags,
}, err }, err
} }
@ -210,7 +211,7 @@ func (mi *MessageInfo) unmarshalExtension(b []byte, num protowire.Number, wtyp p
var err error var err error
xt, err = opts.resolver.FindExtensionByNumber(mi.Desc.FullName(), num) xt, err = opts.resolver.FindExtensionByNumber(mi.Desc.FullName(), num)
if err != nil { if err != nil {
if err == preg.NotFound { if err == protoregistry.NotFound {
return out, errUnknown return out, errUnknown
} }
return out, errors.New("%v: unable to resolve extension %v: %v", mi.Desc.FullName(), num, err) return out, errors.New("%v: unable to resolve extension %v: %v", mi.Desc.FullName(), num, err)

View File

@ -7,15 +7,15 @@ package impl
import ( import (
"reflect" "reflect"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
type EnumInfo struct { type EnumInfo struct {
GoReflectType reflect.Type // int32 kind GoReflectType reflect.Type // int32 kind
Desc pref.EnumDescriptor Desc protoreflect.EnumDescriptor
} }
func (t *EnumInfo) New(n pref.EnumNumber) pref.Enum { func (t *EnumInfo) New(n protoreflect.EnumNumber) protoreflect.Enum {
return reflect.ValueOf(n).Convert(t.GoReflectType).Interface().(pref.Enum) return reflect.ValueOf(n).Convert(t.GoReflectType).Interface().(protoreflect.Enum)
} }
func (t *EnumInfo) Descriptor() pref.EnumDescriptor { return t.Desc } func (t *EnumInfo) Descriptor() protoreflect.EnumDescriptor { return t.Desc }

View File

@ -9,8 +9,8 @@ import (
"sync" "sync"
"sync/atomic" "sync/atomic"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
piface "google.golang.org/protobuf/runtime/protoiface" "google.golang.org/protobuf/runtime/protoiface"
) )
// ExtensionInfo implements ExtensionType. // ExtensionInfo implements ExtensionType.
@ -45,7 +45,7 @@ type ExtensionInfo struct {
// since the message may no longer implement the MessageV1 interface. // since the message may no longer implement the MessageV1 interface.
// //
// Deprecated: Use the ExtendedType method instead. // Deprecated: Use the ExtendedType method instead.
ExtendedType piface.MessageV1 ExtendedType protoiface.MessageV1
// ExtensionType is the zero value of the extension type. // ExtensionType is the zero value of the extension type.
// //
@ -83,31 +83,31 @@ const (
extensionInfoFullInit = 2 extensionInfoFullInit = 2
) )
func InitExtensionInfo(xi *ExtensionInfo, xd pref.ExtensionDescriptor, goType reflect.Type) { func InitExtensionInfo(xi *ExtensionInfo, xd protoreflect.ExtensionDescriptor, goType reflect.Type) {
xi.goType = goType xi.goType = goType
xi.desc = extensionTypeDescriptor{xd, xi} xi.desc = extensionTypeDescriptor{xd, xi}
xi.init = extensionInfoDescInit xi.init = extensionInfoDescInit
} }
func (xi *ExtensionInfo) New() pref.Value { func (xi *ExtensionInfo) New() protoreflect.Value {
return xi.lazyInit().New() return xi.lazyInit().New()
} }
func (xi *ExtensionInfo) Zero() pref.Value { func (xi *ExtensionInfo) Zero() protoreflect.Value {
return xi.lazyInit().Zero() return xi.lazyInit().Zero()
} }
func (xi *ExtensionInfo) ValueOf(v interface{}) pref.Value { func (xi *ExtensionInfo) ValueOf(v interface{}) protoreflect.Value {
return xi.lazyInit().PBValueOf(reflect.ValueOf(v)) return xi.lazyInit().PBValueOf(reflect.ValueOf(v))
} }
func (xi *ExtensionInfo) InterfaceOf(v pref.Value) interface{} { func (xi *ExtensionInfo) InterfaceOf(v protoreflect.Value) interface{} {
return xi.lazyInit().GoValueOf(v).Interface() return xi.lazyInit().GoValueOf(v).Interface()
} }
func (xi *ExtensionInfo) IsValidValue(v pref.Value) bool { func (xi *ExtensionInfo) IsValidValue(v protoreflect.Value) bool {
return xi.lazyInit().IsValidPB(v) return xi.lazyInit().IsValidPB(v)
} }
func (xi *ExtensionInfo) IsValidInterface(v interface{}) bool { func (xi *ExtensionInfo) IsValidInterface(v interface{}) bool {
return xi.lazyInit().IsValidGo(reflect.ValueOf(v)) return xi.lazyInit().IsValidGo(reflect.ValueOf(v))
} }
func (xi *ExtensionInfo) TypeDescriptor() pref.ExtensionTypeDescriptor { func (xi *ExtensionInfo) TypeDescriptor() protoreflect.ExtensionTypeDescriptor {
if atomic.LoadUint32(&xi.init) < extensionInfoDescInit { if atomic.LoadUint32(&xi.init) < extensionInfoDescInit {
xi.lazyInitSlow() xi.lazyInitSlow()
} }
@ -144,13 +144,13 @@ func (xi *ExtensionInfo) lazyInitSlow() {
} }
type extensionTypeDescriptor struct { type extensionTypeDescriptor struct {
pref.ExtensionDescriptor protoreflect.ExtensionDescriptor
xi *ExtensionInfo xi *ExtensionInfo
} }
func (xtd *extensionTypeDescriptor) Type() pref.ExtensionType { func (xtd *extensionTypeDescriptor) Type() protoreflect.ExtensionType {
return xtd.xi return xtd.xi
} }
func (xtd *extensionTypeDescriptor) Descriptor() pref.ExtensionDescriptor { func (xtd *extensionTypeDescriptor) Descriptor() protoreflect.ExtensionDescriptor {
return xtd.ExtensionDescriptor return xtd.ExtensionDescriptor
} }

View File

@ -13,13 +13,12 @@ import (
"google.golang.org/protobuf/internal/filedesc" "google.golang.org/protobuf/internal/filedesc"
"google.golang.org/protobuf/internal/strs" "google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
) )
// legacyEnumName returns the name of enums used in legacy code. // legacyEnumName returns the name of enums used in legacy code.
// It is neither the protobuf full name nor the qualified Go name, // It is neither the protobuf full name nor the qualified Go name,
// but rather an odd hybrid of both. // but rather an odd hybrid of both.
func legacyEnumName(ed pref.EnumDescriptor) string { func legacyEnumName(ed protoreflect.EnumDescriptor) string {
var protoPkg string var protoPkg string
enumName := string(ed.FullName()) enumName := string(ed.FullName())
if fd := ed.ParentFile(); fd != nil { if fd := ed.ParentFile(); fd != nil {
@ -34,68 +33,68 @@ func legacyEnumName(ed pref.EnumDescriptor) string {
// legacyWrapEnum wraps v as a protoreflect.Enum, // legacyWrapEnum wraps v as a protoreflect.Enum,
// where v must be a int32 kind and not implement the v2 API already. // where v must be a int32 kind and not implement the v2 API already.
func legacyWrapEnum(v reflect.Value) pref.Enum { func legacyWrapEnum(v reflect.Value) protoreflect.Enum {
et := legacyLoadEnumType(v.Type()) et := legacyLoadEnumType(v.Type())
return et.New(pref.EnumNumber(v.Int())) return et.New(protoreflect.EnumNumber(v.Int()))
} }
var legacyEnumTypeCache sync.Map // map[reflect.Type]protoreflect.EnumType var legacyEnumTypeCache sync.Map // map[reflect.Type]protoreflect.EnumType
// legacyLoadEnumType dynamically loads a protoreflect.EnumType for t, // legacyLoadEnumType dynamically loads a protoreflect.EnumType for t,
// where t must be an int32 kind and not implement the v2 API already. // where t must be an int32 kind and not implement the v2 API already.
func legacyLoadEnumType(t reflect.Type) pref.EnumType { func legacyLoadEnumType(t reflect.Type) protoreflect.EnumType {
// Fast-path: check if a EnumType is cached for this concrete type. // Fast-path: check if a EnumType is cached for this concrete type.
if et, ok := legacyEnumTypeCache.Load(t); ok { if et, ok := legacyEnumTypeCache.Load(t); ok {
return et.(pref.EnumType) return et.(protoreflect.EnumType)
} }
// Slow-path: derive enum descriptor and initialize EnumType. // Slow-path: derive enum descriptor and initialize EnumType.
var et pref.EnumType var et protoreflect.EnumType
ed := LegacyLoadEnumDesc(t) ed := LegacyLoadEnumDesc(t)
et = &legacyEnumType{ et = &legacyEnumType{
desc: ed, desc: ed,
goType: t, goType: t,
} }
if et, ok := legacyEnumTypeCache.LoadOrStore(t, et); ok { if et, ok := legacyEnumTypeCache.LoadOrStore(t, et); ok {
return et.(pref.EnumType) return et.(protoreflect.EnumType)
} }
return et return et
} }
type legacyEnumType struct { type legacyEnumType struct {
desc pref.EnumDescriptor desc protoreflect.EnumDescriptor
goType reflect.Type goType reflect.Type
m sync.Map // map[protoreflect.EnumNumber]proto.Enum m sync.Map // map[protoreflect.EnumNumber]proto.Enum
} }
func (t *legacyEnumType) New(n pref.EnumNumber) pref.Enum { func (t *legacyEnumType) New(n protoreflect.EnumNumber) protoreflect.Enum {
if e, ok := t.m.Load(n); ok { if e, ok := t.m.Load(n); ok {
return e.(pref.Enum) return e.(protoreflect.Enum)
} }
e := &legacyEnumWrapper{num: n, pbTyp: t, goTyp: t.goType} e := &legacyEnumWrapper{num: n, pbTyp: t, goTyp: t.goType}
t.m.Store(n, e) t.m.Store(n, e)
return e return e
} }
func (t *legacyEnumType) Descriptor() pref.EnumDescriptor { func (t *legacyEnumType) Descriptor() protoreflect.EnumDescriptor {
return t.desc return t.desc
} }
type legacyEnumWrapper struct { type legacyEnumWrapper struct {
num pref.EnumNumber num protoreflect.EnumNumber
pbTyp pref.EnumType pbTyp protoreflect.EnumType
goTyp reflect.Type goTyp reflect.Type
} }
func (e *legacyEnumWrapper) Descriptor() pref.EnumDescriptor { func (e *legacyEnumWrapper) Descriptor() protoreflect.EnumDescriptor {
return e.pbTyp.Descriptor() return e.pbTyp.Descriptor()
} }
func (e *legacyEnumWrapper) Type() pref.EnumType { func (e *legacyEnumWrapper) Type() protoreflect.EnumType {
return e.pbTyp return e.pbTyp
} }
func (e *legacyEnumWrapper) Number() pref.EnumNumber { func (e *legacyEnumWrapper) Number() protoreflect.EnumNumber {
return e.num return e.num
} }
func (e *legacyEnumWrapper) ProtoReflect() pref.Enum { func (e *legacyEnumWrapper) ProtoReflect() protoreflect.Enum {
return e return e
} }
func (e *legacyEnumWrapper) protoUnwrap() interface{} { func (e *legacyEnumWrapper) protoUnwrap() interface{} {
@ -105,7 +104,7 @@ func (e *legacyEnumWrapper) protoUnwrap() interface{} {
} }
var ( var (
_ pref.Enum = (*legacyEnumWrapper)(nil) _ protoreflect.Enum = (*legacyEnumWrapper)(nil)
_ unwrapper = (*legacyEnumWrapper)(nil) _ unwrapper = (*legacyEnumWrapper)(nil)
) )
@ -115,15 +114,15 @@ var legacyEnumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescriptor
// which must be an int32 kind and not implement the v2 API already. // which must be an int32 kind and not implement the v2 API already.
// //
// This is exported for testing purposes. // This is exported for testing purposes.
func LegacyLoadEnumDesc(t reflect.Type) pref.EnumDescriptor { func LegacyLoadEnumDesc(t reflect.Type) protoreflect.EnumDescriptor {
// Fast-path: check if an EnumDescriptor is cached for this concrete type. // Fast-path: check if an EnumDescriptor is cached for this concrete type.
if ed, ok := legacyEnumDescCache.Load(t); ok { if ed, ok := legacyEnumDescCache.Load(t); ok {
return ed.(pref.EnumDescriptor) return ed.(protoreflect.EnumDescriptor)
} }
// Slow-path: initialize EnumDescriptor from the raw descriptor. // Slow-path: initialize EnumDescriptor from the raw descriptor.
ev := reflect.Zero(t).Interface() ev := reflect.Zero(t).Interface()
if _, ok := ev.(pref.Enum); ok { if _, ok := ev.(protoreflect.Enum); ok {
panic(fmt.Sprintf("%v already implements proto.Enum", t)) panic(fmt.Sprintf("%v already implements proto.Enum", t))
} }
edV1, ok := ev.(enumV1) edV1, ok := ev.(enumV1)
@ -132,7 +131,7 @@ func LegacyLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
} }
b, idxs := edV1.EnumDescriptor() b, idxs := edV1.EnumDescriptor()
var ed pref.EnumDescriptor var ed protoreflect.EnumDescriptor
if len(idxs) == 1 { if len(idxs) == 1 {
ed = legacyLoadFileDesc(b).Enums().Get(idxs[0]) ed = legacyLoadFileDesc(b).Enums().Get(idxs[0])
} else { } else {
@ -158,10 +157,10 @@ var aberrantEnumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescript
// We are unable to use the global enum registry since it is // We are unable to use the global enum registry since it is
// unfortunately keyed by the protobuf full name, which we also do not know. // unfortunately keyed by the protobuf full name, which we also do not know.
// Thus, this produces some bogus enum descriptor based on the Go type name. // Thus, this produces some bogus enum descriptor based on the Go type name.
func aberrantLoadEnumDesc(t reflect.Type) pref.EnumDescriptor { func aberrantLoadEnumDesc(t reflect.Type) protoreflect.EnumDescriptor {
// Fast-path: check if an EnumDescriptor is cached for this concrete type. // Fast-path: check if an EnumDescriptor is cached for this concrete type.
if ed, ok := aberrantEnumDescCache.Load(t); ok { if ed, ok := aberrantEnumDescCache.Load(t); ok {
return ed.(pref.EnumDescriptor) return ed.(protoreflect.EnumDescriptor)
} }
// Slow-path: construct a bogus, but unique EnumDescriptor. // Slow-path: construct a bogus, but unique EnumDescriptor.
@ -182,7 +181,7 @@ func aberrantLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
// An exhaustive query is clearly impractical, but can be best-effort. // An exhaustive query is clearly impractical, but can be best-effort.
if ed, ok := aberrantEnumDescCache.LoadOrStore(t, ed); ok { if ed, ok := aberrantEnumDescCache.LoadOrStore(t, ed); ok {
return ed.(pref.EnumDescriptor) return ed.(protoreflect.EnumDescriptor)
} }
return ed return ed
} }
@ -192,7 +191,7 @@ func aberrantLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
// It should be sufficiently unique within a program. // It should be sufficiently unique within a program.
// //
// This is exported for testing purposes. // This is exported for testing purposes.
func AberrantDeriveFullName(t reflect.Type) pref.FullName { func AberrantDeriveFullName(t reflect.Type) protoreflect.FullName {
sanitize := func(r rune) rune { sanitize := func(r rune) rune {
switch { switch {
case r == '/': case r == '/':
@ -215,5 +214,5 @@ func AberrantDeriveFullName(t reflect.Type) pref.FullName {
ss[i] = "x" + s ss[i] = "x" + s
} }
} }
return pref.FullName(strings.Join(ss, ".")) return protoreflect.FullName(strings.Join(ss, "."))
} }

View File

@ -12,21 +12,21 @@ import (
"reflect" "reflect"
"google.golang.org/protobuf/internal/errors" "google.golang.org/protobuf/internal/errors"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
piface "google.golang.org/protobuf/runtime/protoiface" "google.golang.org/protobuf/runtime/protoiface"
) )
// These functions exist to support exported APIs in generated protobufs. // These functions exist to support exported APIs in generated protobufs.
// While these are deprecated, they cannot be removed for compatibility reasons. // While these are deprecated, they cannot be removed for compatibility reasons.
// LegacyEnumName returns the name of enums used in legacy code. // LegacyEnumName returns the name of enums used in legacy code.
func (Export) LegacyEnumName(ed pref.EnumDescriptor) string { func (Export) LegacyEnumName(ed protoreflect.EnumDescriptor) string {
return legacyEnumName(ed) return legacyEnumName(ed)
} }
// LegacyMessageTypeOf returns the protoreflect.MessageType for m, // LegacyMessageTypeOf returns the protoreflect.MessageType for m,
// with name used as the message name if necessary. // with name used as the message name if necessary.
func (Export) LegacyMessageTypeOf(m piface.MessageV1, name pref.FullName) pref.MessageType { func (Export) LegacyMessageTypeOf(m protoiface.MessageV1, name protoreflect.FullName) protoreflect.MessageType {
if mv := (Export{}).protoMessageV2Of(m); mv != nil { if mv := (Export{}).protoMessageV2Of(m); mv != nil {
return mv.ProtoReflect().Type() return mv.ProtoReflect().Type()
} }
@ -36,9 +36,9 @@ func (Export) LegacyMessageTypeOf(m piface.MessageV1, name pref.FullName) pref.M
// UnmarshalJSONEnum unmarshals an enum from a JSON-encoded input. // UnmarshalJSONEnum unmarshals an enum from a JSON-encoded input.
// The input can either be a string representing the enum value by name, // The input can either be a string representing the enum value by name,
// or a number representing the enum number itself. // or a number representing the enum number itself.
func (Export) UnmarshalJSONEnum(ed pref.EnumDescriptor, b []byte) (pref.EnumNumber, error) { func (Export) UnmarshalJSONEnum(ed protoreflect.EnumDescriptor, b []byte) (protoreflect.EnumNumber, error) {
if b[0] == '"' { if b[0] == '"' {
var name pref.Name var name protoreflect.Name
if err := json.Unmarshal(b, &name); err != nil { if err := json.Unmarshal(b, &name); err != nil {
return 0, errors.New("invalid input for enum %v: %s", ed.FullName(), b) return 0, errors.New("invalid input for enum %v: %s", ed.FullName(), b)
} }
@ -48,7 +48,7 @@ func (Export) UnmarshalJSONEnum(ed pref.EnumDescriptor, b []byte) (pref.EnumNumb
} }
return ev.Number(), nil return ev.Number(), nil
} else { } else {
var num pref.EnumNumber var num protoreflect.EnumNumber
if err := json.Unmarshal(b, &num); err != nil { if err := json.Unmarshal(b, &num); err != nil {
return 0, errors.New("invalid input for enum %v: %s", ed.FullName(), b) return 0, errors.New("invalid input for enum %v: %s", ed.FullName(), b)
} }
@ -81,8 +81,8 @@ func (Export) CompressGZIP(in []byte) (out []byte) {
blockHeader[0] = 0x01 // final bit per RFC 1951, section 3.2.3. blockHeader[0] = 0x01 // final bit per RFC 1951, section 3.2.3.
blockSize = len(in) blockSize = len(in)
} }
binary.LittleEndian.PutUint16(blockHeader[1:3], uint16(blockSize)^0x0000) binary.LittleEndian.PutUint16(blockHeader[1:3], uint16(blockSize))
binary.LittleEndian.PutUint16(blockHeader[3:5], uint16(blockSize)^0xffff) binary.LittleEndian.PutUint16(blockHeader[3:5], ^uint16(blockSize))
out = append(out, blockHeader[:]...) out = append(out, blockHeader[:]...)
out = append(out, in[:blockSize]...) out = append(out, in[:blockSize]...)
in = in[blockSize:] in = in[blockSize:]

View File

@ -12,16 +12,16 @@ import (
ptag "google.golang.org/protobuf/internal/encoding/tag" ptag "google.golang.org/protobuf/internal/encoding/tag"
"google.golang.org/protobuf/internal/filedesc" "google.golang.org/protobuf/internal/filedesc"
"google.golang.org/protobuf/internal/pragma" "google.golang.org/protobuf/internal/pragma"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
preg "google.golang.org/protobuf/reflect/protoregistry" "google.golang.org/protobuf/reflect/protoregistry"
piface "google.golang.org/protobuf/runtime/protoiface" "google.golang.org/protobuf/runtime/protoiface"
) )
func (xi *ExtensionInfo) initToLegacy() { func (xi *ExtensionInfo) initToLegacy() {
xd := xi.desc xd := xi.desc
var parent piface.MessageV1 var parent protoiface.MessageV1
messageName := xd.ContainingMessage().FullName() messageName := xd.ContainingMessage().FullName()
if mt, _ := preg.GlobalTypes.FindMessageByName(messageName); mt != nil { if mt, _ := protoregistry.GlobalTypes.FindMessageByName(messageName); mt != nil {
// Create a new parent message and unwrap it if possible. // Create a new parent message and unwrap it if possible.
mv := mt.New().Interface() mv := mt.New().Interface()
t := reflect.TypeOf(mv) t := reflect.TypeOf(mv)
@ -31,7 +31,7 @@ func (xi *ExtensionInfo) initToLegacy() {
// Check whether the message implements the legacy v1 Message interface. // Check whether the message implements the legacy v1 Message interface.
mz := reflect.Zero(t).Interface() mz := reflect.Zero(t).Interface()
if mz, ok := mz.(piface.MessageV1); ok { if mz, ok := mz.(protoiface.MessageV1); ok {
parent = mz parent = mz
} }
} }
@ -46,7 +46,7 @@ func (xi *ExtensionInfo) initToLegacy() {
// Reconstruct the legacy enum full name. // Reconstruct the legacy enum full name.
var enumName string var enumName string
if xd.Kind() == pref.EnumKind { if xd.Kind() == protoreflect.EnumKind {
enumName = legacyEnumName(xd.Enum()) enumName = legacyEnumName(xd.Enum())
} }
@ -77,16 +77,16 @@ func (xi *ExtensionInfo) initFromLegacy() {
// field number is specified. In such a case, use a placeholder. // field number is specified. In such a case, use a placeholder.
if xi.ExtendedType == nil || xi.ExtensionType == nil { if xi.ExtendedType == nil || xi.ExtensionType == nil {
xd := placeholderExtension{ xd := placeholderExtension{
name: pref.FullName(xi.Name), name: protoreflect.FullName(xi.Name),
number: pref.FieldNumber(xi.Field), number: protoreflect.FieldNumber(xi.Field),
} }
xi.desc = extensionTypeDescriptor{xd, xi} xi.desc = extensionTypeDescriptor{xd, xi}
return return
} }
// Resolve enum or message dependencies. // Resolve enum or message dependencies.
var ed pref.EnumDescriptor var ed protoreflect.EnumDescriptor
var md pref.MessageDescriptor var md protoreflect.MessageDescriptor
t := reflect.TypeOf(xi.ExtensionType) t := reflect.TypeOf(xi.ExtensionType)
isOptional := t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct isOptional := t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct
isRepeated := t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 isRepeated := t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
@ -94,18 +94,18 @@ func (xi *ExtensionInfo) initFromLegacy() {
t = t.Elem() t = t.Elem()
} }
switch v := reflect.Zero(t).Interface().(type) { switch v := reflect.Zero(t).Interface().(type) {
case pref.Enum: case protoreflect.Enum:
ed = v.Descriptor() ed = v.Descriptor()
case enumV1: case enumV1:
ed = LegacyLoadEnumDesc(t) ed = LegacyLoadEnumDesc(t)
case pref.ProtoMessage: case protoreflect.ProtoMessage:
md = v.ProtoReflect().Descriptor() md = v.ProtoReflect().Descriptor()
case messageV1: case messageV1:
md = LegacyLoadMessageDesc(t) md = LegacyLoadMessageDesc(t)
} }
// Derive basic field information from the struct tag. // Derive basic field information from the struct tag.
var evs pref.EnumValueDescriptors var evs protoreflect.EnumValueDescriptors
if ed != nil { if ed != nil {
evs = ed.Values() evs = ed.Values()
} }
@ -114,8 +114,8 @@ func (xi *ExtensionInfo) initFromLegacy() {
// Construct a v2 ExtensionType. // Construct a v2 ExtensionType.
xd := &filedesc.Extension{L2: new(filedesc.ExtensionL2)} xd := &filedesc.Extension{L2: new(filedesc.ExtensionL2)}
xd.L0.ParentFile = filedesc.SurrogateProto2 xd.L0.ParentFile = filedesc.SurrogateProto2
xd.L0.FullName = pref.FullName(xi.Name) xd.L0.FullName = protoreflect.FullName(xi.Name)
xd.L1.Number = pref.FieldNumber(xi.Field) xd.L1.Number = protoreflect.FieldNumber(xi.Field)
xd.L1.Cardinality = fd.L1.Cardinality xd.L1.Cardinality = fd.L1.Cardinality
xd.L1.Kind = fd.L1.Kind xd.L1.Kind = fd.L1.Kind
xd.L2.IsPacked = fd.L1.IsPacked xd.L2.IsPacked = fd.L1.IsPacked
@ -138,21 +138,21 @@ func (xi *ExtensionInfo) initFromLegacy() {
} }
type placeholderExtension struct { type placeholderExtension struct {
name pref.FullName name protoreflect.FullName
number pref.FieldNumber number protoreflect.FieldNumber
} }
func (x placeholderExtension) ParentFile() pref.FileDescriptor { return nil } func (x placeholderExtension) ParentFile() protoreflect.FileDescriptor { return nil }
func (x placeholderExtension) Parent() pref.Descriptor { return nil } func (x placeholderExtension) Parent() protoreflect.Descriptor { return nil }
func (x placeholderExtension) Index() int { return 0 } func (x placeholderExtension) Index() int { return 0 }
func (x placeholderExtension) Syntax() pref.Syntax { return 0 } func (x placeholderExtension) Syntax() protoreflect.Syntax { return 0 }
func (x placeholderExtension) Name() pref.Name { return x.name.Name() } func (x placeholderExtension) Name() protoreflect.Name { return x.name.Name() }
func (x placeholderExtension) FullName() pref.FullName { return x.name } func (x placeholderExtension) FullName() protoreflect.FullName { return x.name }
func (x placeholderExtension) IsPlaceholder() bool { return true } func (x placeholderExtension) IsPlaceholder() bool { return true }
func (x placeholderExtension) Options() pref.ProtoMessage { return descopts.Field } func (x placeholderExtension) Options() protoreflect.ProtoMessage { return descopts.Field }
func (x placeholderExtension) Number() pref.FieldNumber { return x.number } func (x placeholderExtension) Number() protoreflect.FieldNumber { return x.number }
func (x placeholderExtension) Cardinality() pref.Cardinality { return 0 } func (x placeholderExtension) Cardinality() protoreflect.Cardinality { return 0 }
func (x placeholderExtension) Kind() pref.Kind { return 0 } func (x placeholderExtension) Kind() protoreflect.Kind { return 0 }
func (x placeholderExtension) HasJSONName() bool { return false } func (x placeholderExtension) HasJSONName() bool { return false }
func (x placeholderExtension) JSONName() string { return "[" + string(x.name) + "]" } func (x placeholderExtension) JSONName() string { return "[" + string(x.name) + "]" }
func (x placeholderExtension) TextName() string { return "[" + string(x.name) + "]" } func (x placeholderExtension) TextName() string { return "[" + string(x.name) + "]" }
@ -163,14 +163,14 @@ func (x placeholderExtension) IsWeak() bool { retu
func (x placeholderExtension) IsPacked() bool { return false } func (x placeholderExtension) IsPacked() bool { return false }
func (x placeholderExtension) IsList() bool { return false } func (x placeholderExtension) IsList() bool { return false }
func (x placeholderExtension) IsMap() bool { return false } func (x placeholderExtension) IsMap() bool { return false }
func (x placeholderExtension) MapKey() pref.FieldDescriptor { return nil } func (x placeholderExtension) MapKey() protoreflect.FieldDescriptor { return nil }
func (x placeholderExtension) MapValue() pref.FieldDescriptor { return nil } func (x placeholderExtension) MapValue() protoreflect.FieldDescriptor { return nil }
func (x placeholderExtension) HasDefault() bool { return false } func (x placeholderExtension) HasDefault() bool { return false }
func (x placeholderExtension) Default() pref.Value { return pref.Value{} } func (x placeholderExtension) Default() protoreflect.Value { return protoreflect.Value{} }
func (x placeholderExtension) DefaultEnumValue() pref.EnumValueDescriptor { return nil } func (x placeholderExtension) DefaultEnumValue() protoreflect.EnumValueDescriptor { return nil }
func (x placeholderExtension) ContainingOneof() pref.OneofDescriptor { return nil } func (x placeholderExtension) ContainingOneof() protoreflect.OneofDescriptor { return nil }
func (x placeholderExtension) ContainingMessage() pref.MessageDescriptor { return nil } func (x placeholderExtension) ContainingMessage() protoreflect.MessageDescriptor { return nil }
func (x placeholderExtension) Enum() pref.EnumDescriptor { return nil } func (x placeholderExtension) Enum() protoreflect.EnumDescriptor { return nil }
func (x placeholderExtension) Message() pref.MessageDescriptor { return nil } func (x placeholderExtension) Message() protoreflect.MessageDescriptor { return nil }
func (x placeholderExtension) ProtoType(pref.FieldDescriptor) { return } func (x placeholderExtension) ProtoType(protoreflect.FieldDescriptor) { return }
func (x placeholderExtension) ProtoInternal(pragma.DoNotImplement) { return } func (x placeholderExtension) ProtoInternal(pragma.DoNotImplement) { return }

View File

@ -16,14 +16,12 @@ import (
"google.golang.org/protobuf/internal/filedesc" "google.golang.org/protobuf/internal/filedesc"
"google.golang.org/protobuf/internal/strs" "google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface" "google.golang.org/protobuf/runtime/protoiface"
piface "google.golang.org/protobuf/runtime/protoiface"
) )
// legacyWrapMessage wraps v as a protoreflect.Message, // legacyWrapMessage wraps v as a protoreflect.Message,
// where v must be a *struct kind and not implement the v2 API already. // where v must be a *struct kind and not implement the v2 API already.
func legacyWrapMessage(v reflect.Value) pref.Message { func legacyWrapMessage(v reflect.Value) protoreflect.Message {
t := v.Type() t := v.Type()
if t.Kind() != reflect.Ptr || t.Elem().Kind() != reflect.Struct { if t.Kind() != reflect.Ptr || t.Elem().Kind() != reflect.Struct {
return aberrantMessage{v: v} return aberrantMessage{v: v}
@ -35,7 +33,7 @@ func legacyWrapMessage(v reflect.Value) pref.Message {
// legacyLoadMessageType dynamically loads a protoreflect.Type for t, // legacyLoadMessageType dynamically loads a protoreflect.Type for t,
// where t must be not implement the v2 API already. // where t must be not implement the v2 API already.
// The provided name is used if it cannot be determined from the message. // The provided name is used if it cannot be determined from the message.
func legacyLoadMessageType(t reflect.Type, name pref.FullName) protoreflect.MessageType { func legacyLoadMessageType(t reflect.Type, name protoreflect.FullName) protoreflect.MessageType {
if t.Kind() != reflect.Ptr || t.Elem().Kind() != reflect.Struct { if t.Kind() != reflect.Ptr || t.Elem().Kind() != reflect.Struct {
return aberrantMessageType{t} return aberrantMessageType{t}
} }
@ -47,7 +45,7 @@ var legacyMessageTypeCache sync.Map // map[reflect.Type]*MessageInfo
// legacyLoadMessageInfo dynamically loads a *MessageInfo for t, // legacyLoadMessageInfo dynamically loads a *MessageInfo for t,
// where t must be a *struct kind and not implement the v2 API already. // where t must be a *struct kind and not implement the v2 API already.
// The provided name is used if it cannot be determined from the message. // The provided name is used if it cannot be determined from the message.
func legacyLoadMessageInfo(t reflect.Type, name pref.FullName) *MessageInfo { func legacyLoadMessageInfo(t reflect.Type, name protoreflect.FullName) *MessageInfo {
// Fast-path: check if a MessageInfo is cached for this concrete type. // Fast-path: check if a MessageInfo is cached for this concrete type.
if mt, ok := legacyMessageTypeCache.Load(t); ok { if mt, ok := legacyMessageTypeCache.Load(t); ok {
return mt.(*MessageInfo) return mt.(*MessageInfo)
@ -68,7 +66,7 @@ func legacyLoadMessageInfo(t reflect.Type, name pref.FullName) *MessageInfo {
// supports deterministic serialization or not, but this // supports deterministic serialization or not, but this
// preserves the v1 implementation's behavior of always // preserves the v1 implementation's behavior of always
// calling Marshal methods when present. // calling Marshal methods when present.
mi.methods.Flags |= piface.SupportMarshalDeterministic mi.methods.Flags |= protoiface.SupportMarshalDeterministic
} }
if _, hasUnmarshal = v.(legacyUnmarshaler); hasUnmarshal { if _, hasUnmarshal = v.(legacyUnmarshaler); hasUnmarshal {
mi.methods.Unmarshal = legacyUnmarshal mi.methods.Unmarshal = legacyUnmarshal
@ -89,18 +87,18 @@ var legacyMessageDescCache sync.Map // map[reflect.Type]protoreflect.MessageDesc
// which should be a *struct kind and must not implement the v2 API already. // which should be a *struct kind and must not implement the v2 API already.
// //
// This is exported for testing purposes. // This is exported for testing purposes.
func LegacyLoadMessageDesc(t reflect.Type) pref.MessageDescriptor { func LegacyLoadMessageDesc(t reflect.Type) protoreflect.MessageDescriptor {
return legacyLoadMessageDesc(t, "") return legacyLoadMessageDesc(t, "")
} }
func legacyLoadMessageDesc(t reflect.Type, name pref.FullName) pref.MessageDescriptor { func legacyLoadMessageDesc(t reflect.Type, name protoreflect.FullName) protoreflect.MessageDescriptor {
// Fast-path: check if a MessageDescriptor is cached for this concrete type. // Fast-path: check if a MessageDescriptor is cached for this concrete type.
if mi, ok := legacyMessageDescCache.Load(t); ok { if mi, ok := legacyMessageDescCache.Load(t); ok {
return mi.(pref.MessageDescriptor) return mi.(protoreflect.MessageDescriptor)
} }
// Slow-path: initialize MessageDescriptor from the raw descriptor. // Slow-path: initialize MessageDescriptor from the raw descriptor.
mv := reflect.Zero(t).Interface() mv := reflect.Zero(t).Interface()
if _, ok := mv.(pref.ProtoMessage); ok { if _, ok := mv.(protoreflect.ProtoMessage); ok {
panic(fmt.Sprintf("%v already implements proto.Message", t)) panic(fmt.Sprintf("%v already implements proto.Message", t))
} }
mdV1, ok := mv.(messageV1) mdV1, ok := mv.(messageV1)
@ -164,7 +162,7 @@ var (
// //
// This is a best-effort derivation of the message descriptor using the protobuf // This is a best-effort derivation of the message descriptor using the protobuf
// tags on the struct fields. // tags on the struct fields.
func aberrantLoadMessageDesc(t reflect.Type, name pref.FullName) pref.MessageDescriptor { func aberrantLoadMessageDesc(t reflect.Type, name protoreflect.FullName) protoreflect.MessageDescriptor {
aberrantMessageDescLock.Lock() aberrantMessageDescLock.Lock()
defer aberrantMessageDescLock.Unlock() defer aberrantMessageDescLock.Unlock()
if aberrantMessageDescCache == nil { if aberrantMessageDescCache == nil {
@ -172,7 +170,7 @@ func aberrantLoadMessageDesc(t reflect.Type, name pref.FullName) pref.MessageDes
} }
return aberrantLoadMessageDescReentrant(t, name) return aberrantLoadMessageDescReentrant(t, name)
} }
func aberrantLoadMessageDescReentrant(t reflect.Type, name pref.FullName) pref.MessageDescriptor { func aberrantLoadMessageDescReentrant(t reflect.Type, name protoreflect.FullName) protoreflect.MessageDescriptor {
// Fast-path: check if an MessageDescriptor is cached for this concrete type. // Fast-path: check if an MessageDescriptor is cached for this concrete type.
if md, ok := aberrantMessageDescCache[t]; ok { if md, ok := aberrantMessageDescCache[t]; ok {
return md return md
@ -225,9 +223,9 @@ func aberrantLoadMessageDescReentrant(t reflect.Type, name pref.FullName) pref.M
vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0] vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0]
for i := 0; i < vs.Len(); i++ { for i := 0; i < vs.Len(); i++ {
v := vs.Index(i) v := vs.Index(i)
md.L2.ExtensionRanges.List = append(md.L2.ExtensionRanges.List, [2]pref.FieldNumber{ md.L2.ExtensionRanges.List = append(md.L2.ExtensionRanges.List, [2]protoreflect.FieldNumber{
pref.FieldNumber(v.FieldByName("Start").Int()), protoreflect.FieldNumber(v.FieldByName("Start").Int()),
pref.FieldNumber(v.FieldByName("End").Int() + 1), protoreflect.FieldNumber(v.FieldByName("End").Int() + 1),
}) })
md.L2.ExtensionRangeOptions = append(md.L2.ExtensionRangeOptions, nil) md.L2.ExtensionRangeOptions = append(md.L2.ExtensionRangeOptions, nil)
} }
@ -245,7 +243,7 @@ func aberrantLoadMessageDescReentrant(t reflect.Type, name pref.FullName) pref.M
n := len(md.L2.Oneofs.List) n := len(md.L2.Oneofs.List)
md.L2.Oneofs.List = append(md.L2.Oneofs.List, filedesc.Oneof{}) md.L2.Oneofs.List = append(md.L2.Oneofs.List, filedesc.Oneof{})
od := &md.L2.Oneofs.List[n] od := &md.L2.Oneofs.List[n]
od.L0.FullName = md.FullName().Append(pref.Name(tag)) od.L0.FullName = md.FullName().Append(protoreflect.Name(tag))
od.L0.ParentFile = md.L0.ParentFile od.L0.ParentFile = md.L0.ParentFile
od.L0.Parent = md od.L0.Parent = md
od.L0.Index = n od.L0.Index = n
@ -267,14 +265,14 @@ func aberrantLoadMessageDescReentrant(t reflect.Type, name pref.FullName) pref.M
return md return md
} }
func aberrantDeriveMessageName(t reflect.Type, name pref.FullName) pref.FullName { func aberrantDeriveMessageName(t reflect.Type, name protoreflect.FullName) protoreflect.FullName {
if name.IsValid() { if name.IsValid() {
return name return name
} }
func() { func() {
defer func() { recover() }() // swallow possible nil panics defer func() { recover() }() // swallow possible nil panics
if m, ok := reflect.Zero(t).Interface().(interface{ XXX_MessageName() string }); ok { if m, ok := reflect.Zero(t).Interface().(interface{ XXX_MessageName() string }); ok {
name = pref.FullName(m.XXX_MessageName()) name = protoreflect.FullName(m.XXX_MessageName())
} }
}() }()
if name.IsValid() { if name.IsValid() {
@ -305,7 +303,7 @@ func aberrantAppendField(md *filedesc.Message, goType reflect.Type, tag, tagKey,
fd.L0.Index = n fd.L0.Index = n
if fd.L1.IsWeak || fd.L1.HasPacked { if fd.L1.IsWeak || fd.L1.HasPacked {
fd.L1.Options = func() pref.ProtoMessage { fd.L1.Options = func() protoreflect.ProtoMessage {
opts := descopts.Field.ProtoReflect().New() opts := descopts.Field.ProtoReflect().New()
if fd.L1.IsWeak { if fd.L1.IsWeak {
opts.Set(opts.Descriptor().Fields().ByName("weak"), protoreflect.ValueOfBool(true)) opts.Set(opts.Descriptor().Fields().ByName("weak"), protoreflect.ValueOfBool(true))
@ -318,17 +316,17 @@ func aberrantAppendField(md *filedesc.Message, goType reflect.Type, tag, tagKey,
} }
// Populate Enum and Message. // Populate Enum and Message.
if fd.Enum() == nil && fd.Kind() == pref.EnumKind { if fd.Enum() == nil && fd.Kind() == protoreflect.EnumKind {
switch v := reflect.Zero(t).Interface().(type) { switch v := reflect.Zero(t).Interface().(type) {
case pref.Enum: case protoreflect.Enum:
fd.L1.Enum = v.Descriptor() fd.L1.Enum = v.Descriptor()
default: default:
fd.L1.Enum = LegacyLoadEnumDesc(t) fd.L1.Enum = LegacyLoadEnumDesc(t)
} }
} }
if fd.Message() == nil && (fd.Kind() == pref.MessageKind || fd.Kind() == pref.GroupKind) { if fd.Message() == nil && (fd.Kind() == protoreflect.MessageKind || fd.Kind() == protoreflect.GroupKind) {
switch v := reflect.Zero(t).Interface().(type) { switch v := reflect.Zero(t).Interface().(type) {
case pref.ProtoMessage: case protoreflect.ProtoMessage:
fd.L1.Message = v.ProtoReflect().Descriptor() fd.L1.Message = v.ProtoReflect().Descriptor()
case messageV1: case messageV1:
fd.L1.Message = LegacyLoadMessageDesc(t) fd.L1.Message = LegacyLoadMessageDesc(t)
@ -337,13 +335,13 @@ func aberrantAppendField(md *filedesc.Message, goType reflect.Type, tag, tagKey,
n := len(md.L1.Messages.List) n := len(md.L1.Messages.List)
md.L1.Messages.List = append(md.L1.Messages.List, filedesc.Message{L2: new(filedesc.MessageL2)}) md.L1.Messages.List = append(md.L1.Messages.List, filedesc.Message{L2: new(filedesc.MessageL2)})
md2 := &md.L1.Messages.List[n] md2 := &md.L1.Messages.List[n]
md2.L0.FullName = md.FullName().Append(pref.Name(strs.MapEntryName(string(fd.Name())))) md2.L0.FullName = md.FullName().Append(protoreflect.Name(strs.MapEntryName(string(fd.Name()))))
md2.L0.ParentFile = md.L0.ParentFile md2.L0.ParentFile = md.L0.ParentFile
md2.L0.Parent = md md2.L0.Parent = md
md2.L0.Index = n md2.L0.Index = n
md2.L1.IsMapEntry = true md2.L1.IsMapEntry = true
md2.L2.Options = func() pref.ProtoMessage { md2.L2.Options = func() protoreflect.ProtoMessage {
opts := descopts.Message.ProtoReflect().New() opts := descopts.Message.ProtoReflect().New()
opts.Set(opts.Descriptor().Fields().ByName("map_entry"), protoreflect.ValueOfBool(true)) opts.Set(opts.Descriptor().Fields().ByName("map_entry"), protoreflect.ValueOfBool(true))
return opts.Interface() return opts.Interface()
@ -364,8 +362,8 @@ type placeholderEnumValues struct {
protoreflect.EnumValueDescriptors protoreflect.EnumValueDescriptors
} }
func (placeholderEnumValues) ByNumber(n pref.EnumNumber) pref.EnumValueDescriptor { func (placeholderEnumValues) ByNumber(n protoreflect.EnumNumber) protoreflect.EnumValueDescriptor {
return filedesc.PlaceholderEnumValue(pref.FullName(fmt.Sprintf("UNKNOWN_%d", n))) return filedesc.PlaceholderEnumValue(protoreflect.FullName(fmt.Sprintf("UNKNOWN_%d", n)))
} }
// legacyMarshaler is the proto.Marshaler interface superseded by protoiface.Methoder. // legacyMarshaler is the proto.Marshaler interface superseded by protoiface.Methoder.
@ -383,7 +381,7 @@ type legacyMerger interface {
Merge(protoiface.MessageV1) Merge(protoiface.MessageV1)
} }
var aberrantProtoMethods = &piface.Methods{ var aberrantProtoMethods = &protoiface.Methods{
Marshal: legacyMarshal, Marshal: legacyMarshal,
Unmarshal: legacyUnmarshal, Unmarshal: legacyUnmarshal,
Merge: legacyMerge, Merge: legacyMerge,
@ -392,40 +390,40 @@ var aberrantProtoMethods = &piface.Methods{
// supports deterministic serialization or not, but this // supports deterministic serialization or not, but this
// preserves the v1 implementation's behavior of always // preserves the v1 implementation's behavior of always
// calling Marshal methods when present. // calling Marshal methods when present.
Flags: piface.SupportMarshalDeterministic, Flags: protoiface.SupportMarshalDeterministic,
} }
func legacyMarshal(in piface.MarshalInput) (piface.MarshalOutput, error) { func legacyMarshal(in protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
v := in.Message.(unwrapper).protoUnwrap() v := in.Message.(unwrapper).protoUnwrap()
marshaler, ok := v.(legacyMarshaler) marshaler, ok := v.(legacyMarshaler)
if !ok { if !ok {
return piface.MarshalOutput{}, errors.New("%T does not implement Marshal", v) return protoiface.MarshalOutput{}, errors.New("%T does not implement Marshal", v)
} }
out, err := marshaler.Marshal() out, err := marshaler.Marshal()
if in.Buf != nil { if in.Buf != nil {
out = append(in.Buf, out...) out = append(in.Buf, out...)
} }
return piface.MarshalOutput{ return protoiface.MarshalOutput{
Buf: out, Buf: out,
}, err }, err
} }
func legacyUnmarshal(in piface.UnmarshalInput) (piface.UnmarshalOutput, error) { func legacyUnmarshal(in protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
v := in.Message.(unwrapper).protoUnwrap() v := in.Message.(unwrapper).protoUnwrap()
unmarshaler, ok := v.(legacyUnmarshaler) unmarshaler, ok := v.(legacyUnmarshaler)
if !ok { if !ok {
return piface.UnmarshalOutput{}, errors.New("%T does not implement Unmarshal", v) return protoiface.UnmarshalOutput{}, errors.New("%T does not implement Unmarshal", v)
} }
return piface.UnmarshalOutput{}, unmarshaler.Unmarshal(in.Buf) return protoiface.UnmarshalOutput{}, unmarshaler.Unmarshal(in.Buf)
} }
func legacyMerge(in piface.MergeInput) piface.MergeOutput { func legacyMerge(in protoiface.MergeInput) protoiface.MergeOutput {
// Check whether this supports the legacy merger. // Check whether this supports the legacy merger.
dstv := in.Destination.(unwrapper).protoUnwrap() dstv := in.Destination.(unwrapper).protoUnwrap()
merger, ok := dstv.(legacyMerger) merger, ok := dstv.(legacyMerger)
if ok { if ok {
merger.Merge(Export{}.ProtoMessageV1Of(in.Source)) merger.Merge(Export{}.ProtoMessageV1Of(in.Source))
return piface.MergeOutput{Flags: piface.MergeComplete} return protoiface.MergeOutput{Flags: protoiface.MergeComplete}
} }
// If legacy merger is unavailable, implement merge in terms of // If legacy merger is unavailable, implement merge in terms of
@ -433,29 +431,29 @@ func legacyMerge(in piface.MergeInput) piface.MergeOutput {
srcv := in.Source.(unwrapper).protoUnwrap() srcv := in.Source.(unwrapper).protoUnwrap()
marshaler, ok := srcv.(legacyMarshaler) marshaler, ok := srcv.(legacyMarshaler)
if !ok { if !ok {
return piface.MergeOutput{} return protoiface.MergeOutput{}
} }
dstv = in.Destination.(unwrapper).protoUnwrap() dstv = in.Destination.(unwrapper).protoUnwrap()
unmarshaler, ok := dstv.(legacyUnmarshaler) unmarshaler, ok := dstv.(legacyUnmarshaler)
if !ok { if !ok {
return piface.MergeOutput{} return protoiface.MergeOutput{}
} }
if !in.Source.IsValid() { if !in.Source.IsValid() {
// Legacy Marshal methods may not function on nil messages. // Legacy Marshal methods may not function on nil messages.
// Check for a typed nil source only after we confirm that // Check for a typed nil source only after we confirm that
// legacy Marshal/Unmarshal methods are present, for // legacy Marshal/Unmarshal methods are present, for
// consistency. // consistency.
return piface.MergeOutput{Flags: piface.MergeComplete} return protoiface.MergeOutput{Flags: protoiface.MergeComplete}
} }
b, err := marshaler.Marshal() b, err := marshaler.Marshal()
if err != nil { if err != nil {
return piface.MergeOutput{} return protoiface.MergeOutput{}
} }
err = unmarshaler.Unmarshal(b) err = unmarshaler.Unmarshal(b)
if err != nil { if err != nil {
return piface.MergeOutput{} return protoiface.MergeOutput{}
} }
return piface.MergeOutput{Flags: piface.MergeComplete} return protoiface.MergeOutput{Flags: protoiface.MergeComplete}
} }
// aberrantMessageType implements MessageType for all types other than pointer-to-struct. // aberrantMessageType implements MessageType for all types other than pointer-to-struct.
@ -463,19 +461,19 @@ type aberrantMessageType struct {
t reflect.Type t reflect.Type
} }
func (mt aberrantMessageType) New() pref.Message { func (mt aberrantMessageType) New() protoreflect.Message {
if mt.t.Kind() == reflect.Ptr { if mt.t.Kind() == reflect.Ptr {
return aberrantMessage{reflect.New(mt.t.Elem())} return aberrantMessage{reflect.New(mt.t.Elem())}
} }
return aberrantMessage{reflect.Zero(mt.t)} return aberrantMessage{reflect.Zero(mt.t)}
} }
func (mt aberrantMessageType) Zero() pref.Message { func (mt aberrantMessageType) Zero() protoreflect.Message {
return aberrantMessage{reflect.Zero(mt.t)} return aberrantMessage{reflect.Zero(mt.t)}
} }
func (mt aberrantMessageType) GoType() reflect.Type { func (mt aberrantMessageType) GoType() reflect.Type {
return mt.t return mt.t
} }
func (mt aberrantMessageType) Descriptor() pref.MessageDescriptor { func (mt aberrantMessageType) Descriptor() protoreflect.MessageDescriptor {
return LegacyLoadMessageDesc(mt.t) return LegacyLoadMessageDesc(mt.t)
} }
@ -499,56 +497,56 @@ func (m aberrantMessage) Reset() {
} }
} }
func (m aberrantMessage) ProtoReflect() pref.Message { func (m aberrantMessage) ProtoReflect() protoreflect.Message {
return m return m
} }
func (m aberrantMessage) Descriptor() pref.MessageDescriptor { func (m aberrantMessage) Descriptor() protoreflect.MessageDescriptor {
return LegacyLoadMessageDesc(m.v.Type()) return LegacyLoadMessageDesc(m.v.Type())
} }
func (m aberrantMessage) Type() pref.MessageType { func (m aberrantMessage) Type() protoreflect.MessageType {
return aberrantMessageType{m.v.Type()} return aberrantMessageType{m.v.Type()}
} }
func (m aberrantMessage) New() pref.Message { func (m aberrantMessage) New() protoreflect.Message {
if m.v.Type().Kind() == reflect.Ptr { if m.v.Type().Kind() == reflect.Ptr {
return aberrantMessage{reflect.New(m.v.Type().Elem())} return aberrantMessage{reflect.New(m.v.Type().Elem())}
} }
return aberrantMessage{reflect.Zero(m.v.Type())} return aberrantMessage{reflect.Zero(m.v.Type())}
} }
func (m aberrantMessage) Interface() pref.ProtoMessage { func (m aberrantMessage) Interface() protoreflect.ProtoMessage {
return m return m
} }
func (m aberrantMessage) Range(f func(pref.FieldDescriptor, pref.Value) bool) { func (m aberrantMessage) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
return return
} }
func (m aberrantMessage) Has(pref.FieldDescriptor) bool { func (m aberrantMessage) Has(protoreflect.FieldDescriptor) bool {
return false return false
} }
func (m aberrantMessage) Clear(pref.FieldDescriptor) { func (m aberrantMessage) Clear(protoreflect.FieldDescriptor) {
panic("invalid Message.Clear on " + string(m.Descriptor().FullName())) panic("invalid Message.Clear on " + string(m.Descriptor().FullName()))
} }
func (m aberrantMessage) Get(fd pref.FieldDescriptor) pref.Value { func (m aberrantMessage) Get(fd protoreflect.FieldDescriptor) protoreflect.Value {
if fd.Default().IsValid() { if fd.Default().IsValid() {
return fd.Default() return fd.Default()
} }
panic("invalid Message.Get on " + string(m.Descriptor().FullName())) panic("invalid Message.Get on " + string(m.Descriptor().FullName()))
} }
func (m aberrantMessage) Set(pref.FieldDescriptor, pref.Value) { func (m aberrantMessage) Set(protoreflect.FieldDescriptor, protoreflect.Value) {
panic("invalid Message.Set on " + string(m.Descriptor().FullName())) panic("invalid Message.Set on " + string(m.Descriptor().FullName()))
} }
func (m aberrantMessage) Mutable(pref.FieldDescriptor) pref.Value { func (m aberrantMessage) Mutable(protoreflect.FieldDescriptor) protoreflect.Value {
panic("invalid Message.Mutable on " + string(m.Descriptor().FullName())) panic("invalid Message.Mutable on " + string(m.Descriptor().FullName()))
} }
func (m aberrantMessage) NewField(pref.FieldDescriptor) pref.Value { func (m aberrantMessage) NewField(protoreflect.FieldDescriptor) protoreflect.Value {
panic("invalid Message.NewField on " + string(m.Descriptor().FullName())) panic("invalid Message.NewField on " + string(m.Descriptor().FullName()))
} }
func (m aberrantMessage) WhichOneof(pref.OneofDescriptor) pref.FieldDescriptor { func (m aberrantMessage) WhichOneof(protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
panic("invalid Message.WhichOneof descriptor on " + string(m.Descriptor().FullName())) panic("invalid Message.WhichOneof descriptor on " + string(m.Descriptor().FullName()))
} }
func (m aberrantMessage) GetUnknown() pref.RawFields { func (m aberrantMessage) GetUnknown() protoreflect.RawFields {
return nil return nil
} }
func (m aberrantMessage) SetUnknown(pref.RawFields) { func (m aberrantMessage) SetUnknown(protoreflect.RawFields) {
// SetUnknown discards its input on messages which don't support unknown field storage. // SetUnknown discards its input on messages which don't support unknown field storage.
} }
func (m aberrantMessage) IsValid() bool { func (m aberrantMessage) IsValid() bool {
@ -557,7 +555,7 @@ func (m aberrantMessage) IsValid() bool {
} }
return false return false
} }
func (m aberrantMessage) ProtoMethods() *piface.Methods { func (m aberrantMessage) ProtoMethods() *protoiface.Methods {
return aberrantProtoMethods return aberrantProtoMethods
} }
func (m aberrantMessage) protoUnwrap() interface{} { func (m aberrantMessage) protoUnwrap() interface{} {

View File

@ -9,8 +9,8 @@ import (
"reflect" "reflect"
"google.golang.org/protobuf/proto" "google.golang.org/protobuf/proto"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
piface "google.golang.org/protobuf/runtime/protoiface" "google.golang.org/protobuf/runtime/protoiface"
) )
type mergeOptions struct{} type mergeOptions struct{}
@ -20,17 +20,17 @@ func (o mergeOptions) Merge(dst, src proto.Message) {
} }
// merge is protoreflect.Methods.Merge. // merge is protoreflect.Methods.Merge.
func (mi *MessageInfo) merge(in piface.MergeInput) piface.MergeOutput { func (mi *MessageInfo) merge(in protoiface.MergeInput) protoiface.MergeOutput {
dp, ok := mi.getPointer(in.Destination) dp, ok := mi.getPointer(in.Destination)
if !ok { if !ok {
return piface.MergeOutput{} return protoiface.MergeOutput{}
} }
sp, ok := mi.getPointer(in.Source) sp, ok := mi.getPointer(in.Source)
if !ok { if !ok {
return piface.MergeOutput{} return protoiface.MergeOutput{}
} }
mi.mergePointer(dp, sp, mergeOptions{}) mi.mergePointer(dp, sp, mergeOptions{})
return piface.MergeOutput{Flags: piface.MergeComplete} return protoiface.MergeOutput{Flags: protoiface.MergeComplete}
} }
func (mi *MessageInfo) mergePointer(dst, src pointer, opts mergeOptions) { func (mi *MessageInfo) mergePointer(dst, src pointer, opts mergeOptions) {
@ -64,7 +64,7 @@ func (mi *MessageInfo) mergePointer(dst, src pointer, opts mergeOptions) {
continue continue
} }
dx := (*dext)[num] dx := (*dext)[num]
var dv pref.Value var dv protoreflect.Value
if dx.Type() == sx.Type() { if dx.Type() == sx.Type() {
dv = dx.Value() dv = dx.Value()
} }
@ -85,15 +85,15 @@ func (mi *MessageInfo) mergePointer(dst, src pointer, opts mergeOptions) {
} }
} }
func mergeScalarValue(dst, src pref.Value, opts mergeOptions) pref.Value { func mergeScalarValue(dst, src protoreflect.Value, opts mergeOptions) protoreflect.Value {
return src return src
} }
func mergeBytesValue(dst, src pref.Value, opts mergeOptions) pref.Value { func mergeBytesValue(dst, src protoreflect.Value, opts mergeOptions) protoreflect.Value {
return pref.ValueOfBytes(append(emptyBuf[:], src.Bytes()...)) return protoreflect.ValueOfBytes(append(emptyBuf[:], src.Bytes()...))
} }
func mergeListValue(dst, src pref.Value, opts mergeOptions) pref.Value { func mergeListValue(dst, src protoreflect.Value, opts mergeOptions) protoreflect.Value {
dstl := dst.List() dstl := dst.List()
srcl := src.List() srcl := src.List()
for i, llen := 0, srcl.Len(); i < llen; i++ { for i, llen := 0, srcl.Len(); i < llen; i++ {
@ -102,29 +102,29 @@ func mergeListValue(dst, src pref.Value, opts mergeOptions) pref.Value {
return dst return dst
} }
func mergeBytesListValue(dst, src pref.Value, opts mergeOptions) pref.Value { func mergeBytesListValue(dst, src protoreflect.Value, opts mergeOptions) protoreflect.Value {
dstl := dst.List() dstl := dst.List()
srcl := src.List() srcl := src.List()
for i, llen := 0, srcl.Len(); i < llen; i++ { for i, llen := 0, srcl.Len(); i < llen; i++ {
sb := srcl.Get(i).Bytes() sb := srcl.Get(i).Bytes()
db := append(emptyBuf[:], sb...) db := append(emptyBuf[:], sb...)
dstl.Append(pref.ValueOfBytes(db)) dstl.Append(protoreflect.ValueOfBytes(db))
} }
return dst return dst
} }
func mergeMessageListValue(dst, src pref.Value, opts mergeOptions) pref.Value { func mergeMessageListValue(dst, src protoreflect.Value, opts mergeOptions) protoreflect.Value {
dstl := dst.List() dstl := dst.List()
srcl := src.List() srcl := src.List()
for i, llen := 0, srcl.Len(); i < llen; i++ { for i, llen := 0, srcl.Len(); i < llen; i++ {
sm := srcl.Get(i).Message() sm := srcl.Get(i).Message()
dm := proto.Clone(sm.Interface()).ProtoReflect() dm := proto.Clone(sm.Interface()).ProtoReflect()
dstl.Append(pref.ValueOfMessage(dm)) dstl.Append(protoreflect.ValueOfMessage(dm))
} }
return dst return dst
} }
func mergeMessageValue(dst, src pref.Value, opts mergeOptions) pref.Value { func mergeMessageValue(dst, src protoreflect.Value, opts mergeOptions) protoreflect.Value {
opts.Merge(dst.Message().Interface(), src.Message().Interface()) opts.Merge(dst.Message().Interface(), src.Message().Interface())
return dst return dst
} }

View File

@ -14,8 +14,7 @@ import (
"google.golang.org/protobuf/internal/genid" "google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoregistry"
preg "google.golang.org/protobuf/reflect/protoregistry"
) )
// MessageInfo provides protobuf related functionality for a given Go type // MessageInfo provides protobuf related functionality for a given Go type
@ -29,7 +28,7 @@ type MessageInfo struct {
GoReflectType reflect.Type // pointer to struct GoReflectType reflect.Type // pointer to struct
// Desc is the underlying message descriptor type and must be populated. // Desc is the underlying message descriptor type and must be populated.
Desc pref.MessageDescriptor Desc protoreflect.MessageDescriptor
// Exporter must be provided in a purego environment in order to provide // Exporter must be provided in a purego environment in order to provide
// access to unexported fields. // access to unexported fields.
@ -54,7 +53,7 @@ type exporter func(v interface{}, i int) interface{}
// is generated by our implementation of protoc-gen-go (for v2 and on). // is generated by our implementation of protoc-gen-go (for v2 and on).
// If it is unable to obtain a MessageInfo, it returns nil. // If it is unable to obtain a MessageInfo, it returns nil.
func getMessageInfo(mt reflect.Type) *MessageInfo { func getMessageInfo(mt reflect.Type) *MessageInfo {
m, ok := reflect.Zero(mt).Interface().(pref.ProtoMessage) m, ok := reflect.Zero(mt).Interface().(protoreflect.ProtoMessage)
if !ok { if !ok {
return nil return nil
} }
@ -97,7 +96,7 @@ func (mi *MessageInfo) initOnce() {
// getPointer returns the pointer for a message, which should be of // getPointer returns the pointer for a message, which should be of
// the type of the MessageInfo. If the message is of a different type, // the type of the MessageInfo. If the message is of a different type,
// it returns ok==false. // it returns ok==false.
func (mi *MessageInfo) getPointer(m pref.Message) (p pointer, ok bool) { func (mi *MessageInfo) getPointer(m protoreflect.Message) (p pointer, ok bool) {
switch m := m.(type) { switch m := m.(type) {
case *messageState: case *messageState:
return m.pointer(), m.messageInfo() == mi return m.pointer(), m.messageInfo() == mi
@ -134,10 +133,10 @@ type structInfo struct {
extensionOffset offset extensionOffset offset
extensionType reflect.Type extensionType reflect.Type
fieldsByNumber map[pref.FieldNumber]reflect.StructField fieldsByNumber map[protoreflect.FieldNumber]reflect.StructField
oneofsByName map[pref.Name]reflect.StructField oneofsByName map[protoreflect.Name]reflect.StructField
oneofWrappersByType map[reflect.Type]pref.FieldNumber oneofWrappersByType map[reflect.Type]protoreflect.FieldNumber
oneofWrappersByNumber map[pref.FieldNumber]reflect.Type oneofWrappersByNumber map[protoreflect.FieldNumber]reflect.Type
} }
func (mi *MessageInfo) makeStructInfo(t reflect.Type) structInfo { func (mi *MessageInfo) makeStructInfo(t reflect.Type) structInfo {
@ -147,10 +146,10 @@ func (mi *MessageInfo) makeStructInfo(t reflect.Type) structInfo {
unknownOffset: invalidOffset, unknownOffset: invalidOffset,
extensionOffset: invalidOffset, extensionOffset: invalidOffset,
fieldsByNumber: map[pref.FieldNumber]reflect.StructField{}, fieldsByNumber: map[protoreflect.FieldNumber]reflect.StructField{},
oneofsByName: map[pref.Name]reflect.StructField{}, oneofsByName: map[protoreflect.Name]reflect.StructField{},
oneofWrappersByType: map[reflect.Type]pref.FieldNumber{}, oneofWrappersByType: map[reflect.Type]protoreflect.FieldNumber{},
oneofWrappersByNumber: map[pref.FieldNumber]reflect.Type{}, oneofWrappersByNumber: map[protoreflect.FieldNumber]reflect.Type{},
} }
fieldLoop: fieldLoop:
@ -180,12 +179,12 @@ fieldLoop:
for _, s := range strings.Split(f.Tag.Get("protobuf"), ",") { for _, s := range strings.Split(f.Tag.Get("protobuf"), ",") {
if len(s) > 0 && strings.Trim(s, "0123456789") == "" { if len(s) > 0 && strings.Trim(s, "0123456789") == "" {
n, _ := strconv.ParseUint(s, 10, 64) n, _ := strconv.ParseUint(s, 10, 64)
si.fieldsByNumber[pref.FieldNumber(n)] = f si.fieldsByNumber[protoreflect.FieldNumber(n)] = f
continue fieldLoop continue fieldLoop
} }
} }
if s := f.Tag.Get("protobuf_oneof"); len(s) > 0 { if s := f.Tag.Get("protobuf_oneof"); len(s) > 0 {
si.oneofsByName[pref.Name(s)] = f si.oneofsByName[protoreflect.Name(s)] = f
continue fieldLoop continue fieldLoop
} }
} }
@ -208,8 +207,8 @@ fieldLoop:
for _, s := range strings.Split(f.Tag.Get("protobuf"), ",") { for _, s := range strings.Split(f.Tag.Get("protobuf"), ",") {
if len(s) > 0 && strings.Trim(s, "0123456789") == "" { if len(s) > 0 && strings.Trim(s, "0123456789") == "" {
n, _ := strconv.ParseUint(s, 10, 64) n, _ := strconv.ParseUint(s, 10, 64)
si.oneofWrappersByType[tf] = pref.FieldNumber(n) si.oneofWrappersByType[tf] = protoreflect.FieldNumber(n)
si.oneofWrappersByNumber[pref.FieldNumber(n)] = tf si.oneofWrappersByNumber[protoreflect.FieldNumber(n)] = tf
break break
} }
} }
@ -219,7 +218,11 @@ fieldLoop:
} }
func (mi *MessageInfo) New() protoreflect.Message { func (mi *MessageInfo) New() protoreflect.Message {
return mi.MessageOf(reflect.New(mi.GoReflectType.Elem()).Interface()) m := reflect.New(mi.GoReflectType.Elem()).Interface()
if r, ok := m.(protoreflect.ProtoMessage); ok {
return r.ProtoReflect()
}
return mi.MessageOf(m)
} }
func (mi *MessageInfo) Zero() protoreflect.Message { func (mi *MessageInfo) Zero() protoreflect.Message {
return mi.MessageOf(reflect.Zero(mi.GoReflectType).Interface()) return mi.MessageOf(reflect.Zero(mi.GoReflectType).Interface())
@ -237,7 +240,7 @@ func (mi *MessageInfo) Message(i int) protoreflect.MessageType {
fd := mi.Desc.Fields().Get(i) fd := mi.Desc.Fields().Get(i)
switch { switch {
case fd.IsWeak(): case fd.IsWeak():
mt, _ := preg.GlobalTypes.FindMessageByName(fd.Message().FullName()) mt, _ := protoregistry.GlobalTypes.FindMessageByName(fd.Message().FullName())
return mt return mt
case fd.IsMap(): case fd.IsMap():
return mapEntryType{fd.Message(), mi.fieldTypes[fd.Number()]} return mapEntryType{fd.Message(), mi.fieldTypes[fd.Number()]}

View File

@ -10,17 +10,17 @@ import (
"google.golang.org/protobuf/internal/detrand" "google.golang.org/protobuf/internal/detrand"
"google.golang.org/protobuf/internal/pragma" "google.golang.org/protobuf/internal/pragma"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
type reflectMessageInfo struct { type reflectMessageInfo struct {
fields map[pref.FieldNumber]*fieldInfo fields map[protoreflect.FieldNumber]*fieldInfo
oneofs map[pref.Name]*oneofInfo oneofs map[protoreflect.Name]*oneofInfo
// fieldTypes contains the zero value of an enum or message field. // fieldTypes contains the zero value of an enum or message field.
// For lists, it contains the element type. // For lists, it contains the element type.
// For maps, it contains the entry value type. // For maps, it contains the entry value type.
fieldTypes map[pref.FieldNumber]interface{} fieldTypes map[protoreflect.FieldNumber]interface{}
// denseFields is a subset of fields where: // denseFields is a subset of fields where:
// 0 < fieldDesc.Number() < len(denseFields) // 0 < fieldDesc.Number() < len(denseFields)
@ -30,8 +30,8 @@ type reflectMessageInfo struct {
// rangeInfos is a list of all fields (not belonging to a oneof) and oneofs. // rangeInfos is a list of all fields (not belonging to a oneof) and oneofs.
rangeInfos []interface{} // either *fieldInfo or *oneofInfo rangeInfos []interface{} // either *fieldInfo or *oneofInfo
getUnknown func(pointer) pref.RawFields getUnknown func(pointer) protoreflect.RawFields
setUnknown func(pointer, pref.RawFields) setUnknown func(pointer, protoreflect.RawFields)
extensionMap func(pointer) *extensionMap extensionMap func(pointer) *extensionMap
nilMessage atomicNilMessage nilMessage atomicNilMessage
@ -52,7 +52,7 @@ func (mi *MessageInfo) makeReflectFuncs(t reflect.Type, si structInfo) {
// This code assumes that the struct is well-formed and panics if there are // This code assumes that the struct is well-formed and panics if there are
// any discrepancies. // any discrepancies.
func (mi *MessageInfo) makeKnownFieldsFunc(si structInfo) { func (mi *MessageInfo) makeKnownFieldsFunc(si structInfo) {
mi.fields = map[pref.FieldNumber]*fieldInfo{} mi.fields = map[protoreflect.FieldNumber]*fieldInfo{}
md := mi.Desc md := mi.Desc
fds := md.Fields() fds := md.Fields()
for i := 0; i < fds.Len(); i++ { for i := 0; i < fds.Len(); i++ {
@ -82,7 +82,7 @@ func (mi *MessageInfo) makeKnownFieldsFunc(si structInfo) {
mi.fields[fd.Number()] = &fi mi.fields[fd.Number()] = &fi
} }
mi.oneofs = map[pref.Name]*oneofInfo{} mi.oneofs = map[protoreflect.Name]*oneofInfo{}
for i := 0; i < md.Oneofs().Len(); i++ { for i := 0; i < md.Oneofs().Len(); i++ {
od := md.Oneofs().Get(i) od := md.Oneofs().Get(i)
mi.oneofs[od.Name()] = makeOneofInfo(od, si, mi.Exporter) mi.oneofs[od.Name()] = makeOneofInfo(od, si, mi.Exporter)
@ -117,13 +117,13 @@ func (mi *MessageInfo) makeUnknownFieldsFunc(t reflect.Type, si structInfo) {
switch { switch {
case si.unknownOffset.IsValid() && si.unknownType == unknownFieldsAType: case si.unknownOffset.IsValid() && si.unknownType == unknownFieldsAType:
// Handle as []byte. // Handle as []byte.
mi.getUnknown = func(p pointer) pref.RawFields { mi.getUnknown = func(p pointer) protoreflect.RawFields {
if p.IsNil() { if p.IsNil() {
return nil return nil
} }
return *p.Apply(mi.unknownOffset).Bytes() return *p.Apply(mi.unknownOffset).Bytes()
} }
mi.setUnknown = func(p pointer, b pref.RawFields) { mi.setUnknown = func(p pointer, b protoreflect.RawFields) {
if p.IsNil() { if p.IsNil() {
panic("invalid SetUnknown on nil Message") panic("invalid SetUnknown on nil Message")
} }
@ -131,7 +131,7 @@ func (mi *MessageInfo) makeUnknownFieldsFunc(t reflect.Type, si structInfo) {
} }
case si.unknownOffset.IsValid() && si.unknownType == unknownFieldsBType: case si.unknownOffset.IsValid() && si.unknownType == unknownFieldsBType:
// Handle as *[]byte. // Handle as *[]byte.
mi.getUnknown = func(p pointer) pref.RawFields { mi.getUnknown = func(p pointer) protoreflect.RawFields {
if p.IsNil() { if p.IsNil() {
return nil return nil
} }
@ -141,7 +141,7 @@ func (mi *MessageInfo) makeUnknownFieldsFunc(t reflect.Type, si structInfo) {
} }
return **bp return **bp
} }
mi.setUnknown = func(p pointer, b pref.RawFields) { mi.setUnknown = func(p pointer, b protoreflect.RawFields) {
if p.IsNil() { if p.IsNil() {
panic("invalid SetUnknown on nil Message") panic("invalid SetUnknown on nil Message")
} }
@ -152,10 +152,10 @@ func (mi *MessageInfo) makeUnknownFieldsFunc(t reflect.Type, si structInfo) {
**bp = b **bp = b
} }
default: default:
mi.getUnknown = func(pointer) pref.RawFields { mi.getUnknown = func(pointer) protoreflect.RawFields {
return nil return nil
} }
mi.setUnknown = func(p pointer, _ pref.RawFields) { mi.setUnknown = func(p pointer, _ protoreflect.RawFields) {
if p.IsNil() { if p.IsNil() {
panic("invalid SetUnknown on nil Message") panic("invalid SetUnknown on nil Message")
} }
@ -224,7 +224,7 @@ func (mi *MessageInfo) makeFieldTypes(si structInfo) {
} }
if ft != nil { if ft != nil {
if mi.fieldTypes == nil { if mi.fieldTypes == nil {
mi.fieldTypes = make(map[pref.FieldNumber]interface{}) mi.fieldTypes = make(map[protoreflect.FieldNumber]interface{})
} }
mi.fieldTypes[fd.Number()] = reflect.Zero(ft).Interface() mi.fieldTypes[fd.Number()] = reflect.Zero(ft).Interface()
} }
@ -233,7 +233,7 @@ func (mi *MessageInfo) makeFieldTypes(si structInfo) {
type extensionMap map[int32]ExtensionField type extensionMap map[int32]ExtensionField
func (m *extensionMap) Range(f func(pref.FieldDescriptor, pref.Value) bool) { func (m *extensionMap) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
if m != nil { if m != nil {
for _, x := range *m { for _, x := range *m {
xd := x.Type().TypeDescriptor() xd := x.Type().TypeDescriptor()
@ -247,7 +247,7 @@ func (m *extensionMap) Range(f func(pref.FieldDescriptor, pref.Value) bool) {
} }
} }
} }
func (m *extensionMap) Has(xt pref.ExtensionType) (ok bool) { func (m *extensionMap) Has(xt protoreflect.ExtensionType) (ok bool) {
if m == nil { if m == nil {
return false return false
} }
@ -266,10 +266,10 @@ func (m *extensionMap) Has(xt pref.ExtensionType) (ok bool) {
} }
return true return true
} }
func (m *extensionMap) Clear(xt pref.ExtensionType) { func (m *extensionMap) Clear(xt protoreflect.ExtensionType) {
delete(*m, int32(xt.TypeDescriptor().Number())) delete(*m, int32(xt.TypeDescriptor().Number()))
} }
func (m *extensionMap) Get(xt pref.ExtensionType) pref.Value { func (m *extensionMap) Get(xt protoreflect.ExtensionType) protoreflect.Value {
xd := xt.TypeDescriptor() xd := xt.TypeDescriptor()
if m != nil { if m != nil {
if x, ok := (*m)[int32(xd.Number())]; ok { if x, ok := (*m)[int32(xd.Number())]; ok {
@ -278,7 +278,7 @@ func (m *extensionMap) Get(xt pref.ExtensionType) pref.Value {
} }
return xt.Zero() return xt.Zero()
} }
func (m *extensionMap) Set(xt pref.ExtensionType, v pref.Value) { func (m *extensionMap) Set(xt protoreflect.ExtensionType, v protoreflect.Value) {
xd := xt.TypeDescriptor() xd := xt.TypeDescriptor()
isValid := true isValid := true
switch { switch {
@ -302,9 +302,9 @@ func (m *extensionMap) Set(xt pref.ExtensionType, v pref.Value) {
x.Set(xt, v) x.Set(xt, v)
(*m)[int32(xd.Number())] = x (*m)[int32(xd.Number())] = x
} }
func (m *extensionMap) Mutable(xt pref.ExtensionType) pref.Value { func (m *extensionMap) Mutable(xt protoreflect.ExtensionType) protoreflect.Value {
xd := xt.TypeDescriptor() xd := xt.TypeDescriptor()
if xd.Kind() != pref.MessageKind && xd.Kind() != pref.GroupKind && !xd.IsList() && !xd.IsMap() { if xd.Kind() != protoreflect.MessageKind && xd.Kind() != protoreflect.GroupKind && !xd.IsList() && !xd.IsMap() {
panic("invalid Mutable on field with non-composite type") panic("invalid Mutable on field with non-composite type")
} }
if x, ok := (*m)[int32(xd.Number())]; ok { if x, ok := (*m)[int32(xd.Number())]; ok {
@ -320,7 +320,6 @@ func (m *extensionMap) Mutable(xt pref.ExtensionType) pref.Value {
// in an allocation-free way without needing to have a shadow Go type generated // in an allocation-free way without needing to have a shadow Go type generated
// for every message type. This technique only works using unsafe. // for every message type. This technique only works using unsafe.
// //
//
// Example generated code: // Example generated code:
// //
// type M struct { // type M struct {
@ -351,11 +350,10 @@ func (m *extensionMap) Mutable(xt pref.ExtensionType) pref.Value {
// It has access to the message info as its first field, and a pointer to the // It has access to the message info as its first field, and a pointer to the
// MessageState is identical to a pointer to the concrete message value. // MessageState is identical to a pointer to the concrete message value.
// //
//
// Requirements: // Requirements:
// The type M must implement protoreflect.ProtoMessage. // - The type M must implement protoreflect.ProtoMessage.
// The address of m must not be nil. // - The address of m must not be nil.
// The address of m and the address of m.state must be equal, // - The address of m and the address of m.state must be equal,
// even though they are different Go types. // even though they are different Go types.
type MessageState struct { type MessageState struct {
pragma.NoUnkeyedLiterals pragma.NoUnkeyedLiterals
@ -368,7 +366,7 @@ type MessageState struct {
type messageState MessageState type messageState MessageState
var ( var (
_ pref.Message = (*messageState)(nil) _ protoreflect.Message = (*messageState)(nil)
_ unwrapper = (*messageState)(nil) _ unwrapper = (*messageState)(nil)
) )
@ -387,16 +385,16 @@ type (
) )
var ( var (
_ pref.Message = (*messageReflectWrapper)(nil) _ protoreflect.Message = (*messageReflectWrapper)(nil)
_ unwrapper = (*messageReflectWrapper)(nil) _ unwrapper = (*messageReflectWrapper)(nil)
_ pref.ProtoMessage = (*messageIfaceWrapper)(nil) _ protoreflect.ProtoMessage = (*messageIfaceWrapper)(nil)
_ unwrapper = (*messageIfaceWrapper)(nil) _ unwrapper = (*messageIfaceWrapper)(nil)
) )
// MessageOf returns a reflective view over a message. The input must be a // MessageOf returns a reflective view over a message. The input must be a
// pointer to a named Go struct. If the provided type has a ProtoReflect method, // pointer to a named Go struct. If the provided type has a ProtoReflect method,
// it must be implemented by calling this method. // it must be implemented by calling this method.
func (mi *MessageInfo) MessageOf(m interface{}) pref.Message { func (mi *MessageInfo) MessageOf(m interface{}) protoreflect.Message {
if reflect.TypeOf(m) != mi.GoReflectType { if reflect.TypeOf(m) != mi.GoReflectType {
panic(fmt.Sprintf("type mismatch: got %T, want %v", m, mi.GoReflectType)) panic(fmt.Sprintf("type mismatch: got %T, want %v", m, mi.GoReflectType))
} }
@ -421,7 +419,7 @@ func (m *messageIfaceWrapper) Reset() {
rv.Elem().Set(reflect.Zero(rv.Type().Elem())) rv.Elem().Set(reflect.Zero(rv.Type().Elem()))
} }
} }
func (m *messageIfaceWrapper) ProtoReflect() pref.Message { func (m *messageIfaceWrapper) ProtoReflect() protoreflect.Message {
return (*messageReflectWrapper)(m) return (*messageReflectWrapper)(m)
} }
func (m *messageIfaceWrapper) protoUnwrap() interface{} { func (m *messageIfaceWrapper) protoUnwrap() interface{} {
@ -430,7 +428,7 @@ func (m *messageIfaceWrapper) protoUnwrap() interface{} {
// checkField verifies that the provided field descriptor is valid. // checkField verifies that the provided field descriptor is valid.
// Exactly one of the returned values is populated. // Exactly one of the returned values is populated.
func (mi *MessageInfo) checkField(fd pref.FieldDescriptor) (*fieldInfo, pref.ExtensionType) { func (mi *MessageInfo) checkField(fd protoreflect.FieldDescriptor) (*fieldInfo, protoreflect.ExtensionType) {
var fi *fieldInfo var fi *fieldInfo
if n := fd.Number(); 0 < n && int(n) < len(mi.denseFields) { if n := fd.Number(); 0 < n && int(n) < len(mi.denseFields) {
fi = mi.denseFields[n] fi = mi.denseFields[n]
@ -455,7 +453,7 @@ func (mi *MessageInfo) checkField(fd pref.FieldDescriptor) (*fieldInfo, pref.Ext
if !mi.Desc.ExtensionRanges().Has(fd.Number()) { if !mi.Desc.ExtensionRanges().Has(fd.Number()) {
panic(fmt.Sprintf("extension %v extends %v outside the extension range", fd.FullName(), mi.Desc.FullName())) panic(fmt.Sprintf("extension %v extends %v outside the extension range", fd.FullName(), mi.Desc.FullName()))
} }
xtd, ok := fd.(pref.ExtensionTypeDescriptor) xtd, ok := fd.(protoreflect.ExtensionTypeDescriptor)
if !ok { if !ok {
panic(fmt.Sprintf("extension %v does not implement protoreflect.ExtensionTypeDescriptor", fd.FullName())) panic(fmt.Sprintf("extension %v does not implement protoreflect.ExtensionTypeDescriptor", fd.FullName()))
} }

View File

@ -11,24 +11,24 @@ import (
"sync" "sync"
"google.golang.org/protobuf/internal/flags" "google.golang.org/protobuf/internal/flags"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
preg "google.golang.org/protobuf/reflect/protoregistry" "google.golang.org/protobuf/reflect/protoregistry"
) )
type fieldInfo struct { type fieldInfo struct {
fieldDesc pref.FieldDescriptor fieldDesc protoreflect.FieldDescriptor
// These fields are used for protobuf reflection support. // These fields are used for protobuf reflection support.
has func(pointer) bool has func(pointer) bool
clear func(pointer) clear func(pointer)
get func(pointer) pref.Value get func(pointer) protoreflect.Value
set func(pointer, pref.Value) set func(pointer, protoreflect.Value)
mutable func(pointer) pref.Value mutable func(pointer) protoreflect.Value
newMessage func() pref.Message newMessage func() protoreflect.Message
newField func() pref.Value newField func() protoreflect.Value
} }
func fieldInfoForMissing(fd pref.FieldDescriptor) fieldInfo { func fieldInfoForMissing(fd protoreflect.FieldDescriptor) fieldInfo {
// This never occurs for generated message types. // This never occurs for generated message types.
// It implies that a hand-crafted type has missing Go fields // It implies that a hand-crafted type has missing Go fields
// for specific protobuf message fields. // for specific protobuf message fields.
@ -40,19 +40,19 @@ func fieldInfoForMissing(fd pref.FieldDescriptor) fieldInfo {
clear: func(p pointer) { clear: func(p pointer) {
panic("missing Go struct field for " + string(fd.FullName())) panic("missing Go struct field for " + string(fd.FullName()))
}, },
get: func(p pointer) pref.Value { get: func(p pointer) protoreflect.Value {
return fd.Default() return fd.Default()
}, },
set: func(p pointer, v pref.Value) { set: func(p pointer, v protoreflect.Value) {
panic("missing Go struct field for " + string(fd.FullName())) panic("missing Go struct field for " + string(fd.FullName()))
}, },
mutable: func(p pointer) pref.Value { mutable: func(p pointer) protoreflect.Value {
panic("missing Go struct field for " + string(fd.FullName())) panic("missing Go struct field for " + string(fd.FullName()))
}, },
newMessage: func() pref.Message { newMessage: func() protoreflect.Message {
panic("missing Go struct field for " + string(fd.FullName())) panic("missing Go struct field for " + string(fd.FullName()))
}, },
newField: func() pref.Value { newField: func() protoreflect.Value {
if v := fd.Default(); v.IsValid() { if v := fd.Default(); v.IsValid() {
return v return v
} }
@ -61,7 +61,7 @@ func fieldInfoForMissing(fd pref.FieldDescriptor) fieldInfo {
} }
} }
func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, x exporter, ot reflect.Type) fieldInfo { func fieldInfoForOneof(fd protoreflect.FieldDescriptor, fs reflect.StructField, x exporter, ot reflect.Type) fieldInfo {
ft := fs.Type ft := fs.Type
if ft.Kind() != reflect.Interface { if ft.Kind() != reflect.Interface {
panic(fmt.Sprintf("field %v has invalid type: got %v, want interface kind", fd.FullName(), ft)) panic(fmt.Sprintf("field %v has invalid type: got %v, want interface kind", fd.FullName(), ft))
@ -102,7 +102,7 @@ func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, x export
} }
rv.Set(reflect.Zero(rv.Type())) rv.Set(reflect.Zero(rv.Type()))
}, },
get: func(p pointer) pref.Value { get: func(p pointer) protoreflect.Value {
if p.IsNil() { if p.IsNil() {
return conv.Zero() return conv.Zero()
} }
@ -113,7 +113,7 @@ func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, x export
rv = rv.Elem().Elem().Field(0) rv = rv.Elem().Elem().Field(0)
return conv.PBValueOf(rv) return conv.PBValueOf(rv)
}, },
set: func(p pointer, v pref.Value) { set: func(p pointer, v protoreflect.Value) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem() rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() { if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
rv.Set(reflect.New(ot)) rv.Set(reflect.New(ot))
@ -121,7 +121,7 @@ func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, x export
rv = rv.Elem().Elem().Field(0) rv = rv.Elem().Elem().Field(0)
rv.Set(conv.GoValueOf(v)) rv.Set(conv.GoValueOf(v))
}, },
mutable: func(p pointer) pref.Value { mutable: func(p pointer) protoreflect.Value {
if !isMessage { if !isMessage {
panic(fmt.Sprintf("field %v with invalid Mutable call on field with non-composite type", fd.FullName())) panic(fmt.Sprintf("field %v with invalid Mutable call on field with non-composite type", fd.FullName()))
} }
@ -131,20 +131,20 @@ func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, x export
} }
rv = rv.Elem().Elem().Field(0) rv = rv.Elem().Elem().Field(0)
if rv.Kind() == reflect.Ptr && rv.IsNil() { if rv.Kind() == reflect.Ptr && rv.IsNil() {
rv.Set(conv.GoValueOf(pref.ValueOfMessage(conv.New().Message()))) rv.Set(conv.GoValueOf(protoreflect.ValueOfMessage(conv.New().Message())))
} }
return conv.PBValueOf(rv) return conv.PBValueOf(rv)
}, },
newMessage: func() pref.Message { newMessage: func() protoreflect.Message {
return conv.New().Message() return conv.New().Message()
}, },
newField: func() pref.Value { newField: func() protoreflect.Value {
return conv.New() return conv.New()
}, },
} }
} }
func fieldInfoForMap(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo { func fieldInfoForMap(fd protoreflect.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
ft := fs.Type ft := fs.Type
if ft.Kind() != reflect.Map { if ft.Kind() != reflect.Map {
panic(fmt.Sprintf("field %v has invalid type: got %v, want map kind", fd.FullName(), ft)) panic(fmt.Sprintf("field %v has invalid type: got %v, want map kind", fd.FullName(), ft))
@ -166,7 +166,7 @@ func fieldInfoForMap(fd pref.FieldDescriptor, fs reflect.StructField, x exporter
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem() rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
rv.Set(reflect.Zero(rv.Type())) rv.Set(reflect.Zero(rv.Type()))
}, },
get: func(p pointer) pref.Value { get: func(p pointer) protoreflect.Value {
if p.IsNil() { if p.IsNil() {
return conv.Zero() return conv.Zero()
} }
@ -176,7 +176,7 @@ func fieldInfoForMap(fd pref.FieldDescriptor, fs reflect.StructField, x exporter
} }
return conv.PBValueOf(rv) return conv.PBValueOf(rv)
}, },
set: func(p pointer, v pref.Value) { set: func(p pointer, v protoreflect.Value) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem() rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
pv := conv.GoValueOf(v) pv := conv.GoValueOf(v)
if pv.IsNil() { if pv.IsNil() {
@ -184,20 +184,20 @@ func fieldInfoForMap(fd pref.FieldDescriptor, fs reflect.StructField, x exporter
} }
rv.Set(pv) rv.Set(pv)
}, },
mutable: func(p pointer) pref.Value { mutable: func(p pointer) protoreflect.Value {
v := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem() v := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if v.IsNil() { if v.IsNil() {
v.Set(reflect.MakeMap(fs.Type)) v.Set(reflect.MakeMap(fs.Type))
} }
return conv.PBValueOf(v) return conv.PBValueOf(v)
}, },
newField: func() pref.Value { newField: func() protoreflect.Value {
return conv.New() return conv.New()
}, },
} }
} }
func fieldInfoForList(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo { func fieldInfoForList(fd protoreflect.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
ft := fs.Type ft := fs.Type
if ft.Kind() != reflect.Slice { if ft.Kind() != reflect.Slice {
panic(fmt.Sprintf("field %v has invalid type: got %v, want slice kind", fd.FullName(), ft)) panic(fmt.Sprintf("field %v has invalid type: got %v, want slice kind", fd.FullName(), ft))
@ -219,7 +219,7 @@ func fieldInfoForList(fd pref.FieldDescriptor, fs reflect.StructField, x exporte
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem() rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
rv.Set(reflect.Zero(rv.Type())) rv.Set(reflect.Zero(rv.Type()))
}, },
get: func(p pointer) pref.Value { get: func(p pointer) protoreflect.Value {
if p.IsNil() { if p.IsNil() {
return conv.Zero() return conv.Zero()
} }
@ -229,7 +229,7 @@ func fieldInfoForList(fd pref.FieldDescriptor, fs reflect.StructField, x exporte
} }
return conv.PBValueOf(rv) return conv.PBValueOf(rv)
}, },
set: func(p pointer, v pref.Value) { set: func(p pointer, v protoreflect.Value) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem() rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
pv := conv.GoValueOf(v) pv := conv.GoValueOf(v)
if pv.IsNil() { if pv.IsNil() {
@ -237,11 +237,11 @@ func fieldInfoForList(fd pref.FieldDescriptor, fs reflect.StructField, x exporte
} }
rv.Set(pv.Elem()) rv.Set(pv.Elem())
}, },
mutable: func(p pointer) pref.Value { mutable: func(p pointer) protoreflect.Value {
v := p.Apply(fieldOffset).AsValueOf(fs.Type) v := p.Apply(fieldOffset).AsValueOf(fs.Type)
return conv.PBValueOf(v) return conv.PBValueOf(v)
}, },
newField: func() pref.Value { newField: func() protoreflect.Value {
return conv.New() return conv.New()
}, },
} }
@ -252,7 +252,7 @@ var (
emptyBytes = reflect.ValueOf([]byte{}) emptyBytes = reflect.ValueOf([]byte{})
) )
func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo { func fieldInfoForScalar(fd protoreflect.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
ft := fs.Type ft := fs.Type
nullable := fd.HasPresence() nullable := fd.HasPresence()
isBytes := ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 isBytes := ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8
@ -300,7 +300,7 @@ func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField, x expor
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem() rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
rv.Set(reflect.Zero(rv.Type())) rv.Set(reflect.Zero(rv.Type()))
}, },
get: func(p pointer) pref.Value { get: func(p pointer) protoreflect.Value {
if p.IsNil() { if p.IsNil() {
return conv.Zero() return conv.Zero()
} }
@ -315,7 +315,7 @@ func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField, x expor
} }
return conv.PBValueOf(rv) return conv.PBValueOf(rv)
}, },
set: func(p pointer, v pref.Value) { set: func(p pointer, v protoreflect.Value) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem() rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if nullable && rv.Kind() == reflect.Ptr { if nullable && rv.Kind() == reflect.Ptr {
if rv.IsNil() { if rv.IsNil() {
@ -332,23 +332,23 @@ func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField, x expor
} }
} }
}, },
newField: func() pref.Value { newField: func() protoreflect.Value {
return conv.New() return conv.New()
}, },
} }
} }
func fieldInfoForWeakMessage(fd pref.FieldDescriptor, weakOffset offset) fieldInfo { func fieldInfoForWeakMessage(fd protoreflect.FieldDescriptor, weakOffset offset) fieldInfo {
if !flags.ProtoLegacy { if !flags.ProtoLegacy {
panic("no support for proto1 weak fields") panic("no support for proto1 weak fields")
} }
var once sync.Once var once sync.Once
var messageType pref.MessageType var messageType protoreflect.MessageType
lazyInit := func() { lazyInit := func() {
once.Do(func() { once.Do(func() {
messageName := fd.Message().FullName() messageName := fd.Message().FullName()
messageType, _ = preg.GlobalTypes.FindMessageByName(messageName) messageType, _ = protoregistry.GlobalTypes.FindMessageByName(messageName)
if messageType == nil { if messageType == nil {
panic(fmt.Sprintf("weak message %v for field %v is not linked in", messageName, fd.FullName())) panic(fmt.Sprintf("weak message %v for field %v is not linked in", messageName, fd.FullName()))
} }
@ -368,18 +368,18 @@ func fieldInfoForWeakMessage(fd pref.FieldDescriptor, weakOffset offset) fieldIn
clear: func(p pointer) { clear: func(p pointer) {
p.Apply(weakOffset).WeakFields().clear(num) p.Apply(weakOffset).WeakFields().clear(num)
}, },
get: func(p pointer) pref.Value { get: func(p pointer) protoreflect.Value {
lazyInit() lazyInit()
if p.IsNil() { if p.IsNil() {
return pref.ValueOfMessage(messageType.Zero()) return protoreflect.ValueOfMessage(messageType.Zero())
} }
m, ok := p.Apply(weakOffset).WeakFields().get(num) m, ok := p.Apply(weakOffset).WeakFields().get(num)
if !ok { if !ok {
return pref.ValueOfMessage(messageType.Zero()) return protoreflect.ValueOfMessage(messageType.Zero())
} }
return pref.ValueOfMessage(m.ProtoReflect()) return protoreflect.ValueOfMessage(m.ProtoReflect())
}, },
set: func(p pointer, v pref.Value) { set: func(p pointer, v protoreflect.Value) {
lazyInit() lazyInit()
m := v.Message() m := v.Message()
if m.Descriptor() != messageType.Descriptor() { if m.Descriptor() != messageType.Descriptor() {
@ -390,7 +390,7 @@ func fieldInfoForWeakMessage(fd pref.FieldDescriptor, weakOffset offset) fieldIn
} }
p.Apply(weakOffset).WeakFields().set(num, m.Interface()) p.Apply(weakOffset).WeakFields().set(num, m.Interface())
}, },
mutable: func(p pointer) pref.Value { mutable: func(p pointer) protoreflect.Value {
lazyInit() lazyInit()
fs := p.Apply(weakOffset).WeakFields() fs := p.Apply(weakOffset).WeakFields()
m, ok := fs.get(num) m, ok := fs.get(num)
@ -398,20 +398,20 @@ func fieldInfoForWeakMessage(fd pref.FieldDescriptor, weakOffset offset) fieldIn
m = messageType.New().Interface() m = messageType.New().Interface()
fs.set(num, m) fs.set(num, m)
} }
return pref.ValueOfMessage(m.ProtoReflect()) return protoreflect.ValueOfMessage(m.ProtoReflect())
}, },
newMessage: func() pref.Message { newMessage: func() protoreflect.Message {
lazyInit() lazyInit()
return messageType.New() return messageType.New()
}, },
newField: func() pref.Value { newField: func() protoreflect.Value {
lazyInit() lazyInit()
return pref.ValueOfMessage(messageType.New()) return protoreflect.ValueOfMessage(messageType.New())
}, },
} }
} }
func fieldInfoForMessage(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo { func fieldInfoForMessage(fd protoreflect.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
ft := fs.Type ft := fs.Type
conv := NewConverter(ft, fd) conv := NewConverter(ft, fd)
@ -433,47 +433,47 @@ func fieldInfoForMessage(fd pref.FieldDescriptor, fs reflect.StructField, x expo
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem() rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
rv.Set(reflect.Zero(rv.Type())) rv.Set(reflect.Zero(rv.Type()))
}, },
get: func(p pointer) pref.Value { get: func(p pointer) protoreflect.Value {
if p.IsNil() { if p.IsNil() {
return conv.Zero() return conv.Zero()
} }
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem() rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
return conv.PBValueOf(rv) return conv.PBValueOf(rv)
}, },
set: func(p pointer, v pref.Value) { set: func(p pointer, v protoreflect.Value) {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem() rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
rv.Set(conv.GoValueOf(v)) rv.Set(conv.GoValueOf(v))
if fs.Type.Kind() == reflect.Ptr && rv.IsNil() { if fs.Type.Kind() == reflect.Ptr && rv.IsNil() {
panic(fmt.Sprintf("field %v has invalid nil pointer", fd.FullName())) panic(fmt.Sprintf("field %v has invalid nil pointer", fd.FullName()))
} }
}, },
mutable: func(p pointer) pref.Value { mutable: func(p pointer) protoreflect.Value {
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem() rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
if fs.Type.Kind() == reflect.Ptr && rv.IsNil() { if fs.Type.Kind() == reflect.Ptr && rv.IsNil() {
rv.Set(conv.GoValueOf(conv.New())) rv.Set(conv.GoValueOf(conv.New()))
} }
return conv.PBValueOf(rv) return conv.PBValueOf(rv)
}, },
newMessage: func() pref.Message { newMessage: func() protoreflect.Message {
return conv.New().Message() return conv.New().Message()
}, },
newField: func() pref.Value { newField: func() protoreflect.Value {
return conv.New() return conv.New()
}, },
} }
} }
type oneofInfo struct { type oneofInfo struct {
oneofDesc pref.OneofDescriptor oneofDesc protoreflect.OneofDescriptor
which func(pointer) pref.FieldNumber which func(pointer) protoreflect.FieldNumber
} }
func makeOneofInfo(od pref.OneofDescriptor, si structInfo, x exporter) *oneofInfo { func makeOneofInfo(od protoreflect.OneofDescriptor, si structInfo, x exporter) *oneofInfo {
oi := &oneofInfo{oneofDesc: od} oi := &oneofInfo{oneofDesc: od}
if od.IsSynthetic() { if od.IsSynthetic() {
fs := si.fieldsByNumber[od.Fields().Get(0).Number()] fs := si.fieldsByNumber[od.Fields().Get(0).Number()]
fieldOffset := offsetOf(fs, x) fieldOffset := offsetOf(fs, x)
oi.which = func(p pointer) pref.FieldNumber { oi.which = func(p pointer) protoreflect.FieldNumber {
if p.IsNil() { if p.IsNil() {
return 0 return 0
} }
@ -486,7 +486,7 @@ func makeOneofInfo(od pref.OneofDescriptor, si structInfo, x exporter) *oneofInf
} else { } else {
fs := si.oneofsByName[od.Name()] fs := si.oneofsByName[od.Name()]
fieldOffset := offsetOf(fs, x) fieldOffset := offsetOf(fs, x)
oi.which = func(p pointer) pref.FieldNumber { oi.which = func(p pointer) protoreflect.FieldNumber {
if p.IsNil() { if p.IsNil() {
return 0 return 0
} }

View File

@ -16,9 +16,9 @@ import (
"google.golang.org/protobuf/internal/flags" "google.golang.org/protobuf/internal/flags"
"google.golang.org/protobuf/internal/genid" "google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/internal/strs" "google.golang.org/protobuf/internal/strs"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
preg "google.golang.org/protobuf/reflect/protoregistry" "google.golang.org/protobuf/reflect/protoregistry"
piface "google.golang.org/protobuf/runtime/protoiface" "google.golang.org/protobuf/runtime/protoiface"
) )
// ValidationStatus is the result of validating the wire-format encoding of a message. // ValidationStatus is the result of validating the wire-format encoding of a message.
@ -56,20 +56,20 @@ func (v ValidationStatus) String() string {
// of the message type. // of the message type.
// //
// This function is exposed for testing. // This function is exposed for testing.
func Validate(mt pref.MessageType, in piface.UnmarshalInput) (out piface.UnmarshalOutput, _ ValidationStatus) { func Validate(mt protoreflect.MessageType, in protoiface.UnmarshalInput) (out protoiface.UnmarshalOutput, _ ValidationStatus) {
mi, ok := mt.(*MessageInfo) mi, ok := mt.(*MessageInfo)
if !ok { if !ok {
return out, ValidationUnknown return out, ValidationUnknown
} }
if in.Resolver == nil { if in.Resolver == nil {
in.Resolver = preg.GlobalTypes in.Resolver = protoregistry.GlobalTypes
} }
o, st := mi.validate(in.Buf, 0, unmarshalOptions{ o, st := mi.validate(in.Buf, 0, unmarshalOptions{
flags: in.Flags, flags: in.Flags,
resolver: in.Resolver, resolver: in.Resolver,
}) })
if o.initialized { if o.initialized {
out.Flags |= piface.UnmarshalInitialized out.Flags |= protoiface.UnmarshalInitialized
} }
return out, st return out, st
} }
@ -106,22 +106,22 @@ const (
validationTypeMessageSetItem validationTypeMessageSetItem
) )
func newFieldValidationInfo(mi *MessageInfo, si structInfo, fd pref.FieldDescriptor, ft reflect.Type) validationInfo { func newFieldValidationInfo(mi *MessageInfo, si structInfo, fd protoreflect.FieldDescriptor, ft reflect.Type) validationInfo {
var vi validationInfo var vi validationInfo
switch { switch {
case fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic(): case fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic():
switch fd.Kind() { switch fd.Kind() {
case pref.MessageKind: case protoreflect.MessageKind:
vi.typ = validationTypeMessage vi.typ = validationTypeMessage
if ot, ok := si.oneofWrappersByNumber[fd.Number()]; ok { if ot, ok := si.oneofWrappersByNumber[fd.Number()]; ok {
vi.mi = getMessageInfo(ot.Field(0).Type) vi.mi = getMessageInfo(ot.Field(0).Type)
} }
case pref.GroupKind: case protoreflect.GroupKind:
vi.typ = validationTypeGroup vi.typ = validationTypeGroup
if ot, ok := si.oneofWrappersByNumber[fd.Number()]; ok { if ot, ok := si.oneofWrappersByNumber[fd.Number()]; ok {
vi.mi = getMessageInfo(ot.Field(0).Type) vi.mi = getMessageInfo(ot.Field(0).Type)
} }
case pref.StringKind: case protoreflect.StringKind:
if strs.EnforceUTF8(fd) { if strs.EnforceUTF8(fd) {
vi.typ = validationTypeUTF8String vi.typ = validationTypeUTF8String
} }
@ -129,7 +129,7 @@ func newFieldValidationInfo(mi *MessageInfo, si structInfo, fd pref.FieldDescrip
default: default:
vi = newValidationInfo(fd, ft) vi = newValidationInfo(fd, ft)
} }
if fd.Cardinality() == pref.Required { if fd.Cardinality() == protoreflect.Required {
// Avoid overflow. The required field check is done with a 64-bit mask, with // Avoid overflow. The required field check is done with a 64-bit mask, with
// any message containing more than 64 required fields always reported as // any message containing more than 64 required fields always reported as
// potentially uninitialized, so it is not important to get a precise count // potentially uninitialized, so it is not important to get a precise count
@ -142,22 +142,22 @@ func newFieldValidationInfo(mi *MessageInfo, si structInfo, fd pref.FieldDescrip
return vi return vi
} }
func newValidationInfo(fd pref.FieldDescriptor, ft reflect.Type) validationInfo { func newValidationInfo(fd protoreflect.FieldDescriptor, ft reflect.Type) validationInfo {
var vi validationInfo var vi validationInfo
switch { switch {
case fd.IsList(): case fd.IsList():
switch fd.Kind() { switch fd.Kind() {
case pref.MessageKind: case protoreflect.MessageKind:
vi.typ = validationTypeMessage vi.typ = validationTypeMessage
if ft.Kind() == reflect.Slice { if ft.Kind() == reflect.Slice {
vi.mi = getMessageInfo(ft.Elem()) vi.mi = getMessageInfo(ft.Elem())
} }
case pref.GroupKind: case protoreflect.GroupKind:
vi.typ = validationTypeGroup vi.typ = validationTypeGroup
if ft.Kind() == reflect.Slice { if ft.Kind() == reflect.Slice {
vi.mi = getMessageInfo(ft.Elem()) vi.mi = getMessageInfo(ft.Elem())
} }
case pref.StringKind: case protoreflect.StringKind:
vi.typ = validationTypeBytes vi.typ = validationTypeBytes
if strs.EnforceUTF8(fd) { if strs.EnforceUTF8(fd) {
vi.typ = validationTypeUTF8String vi.typ = validationTypeUTF8String
@ -175,33 +175,33 @@ func newValidationInfo(fd pref.FieldDescriptor, ft reflect.Type) validationInfo
case fd.IsMap(): case fd.IsMap():
vi.typ = validationTypeMap vi.typ = validationTypeMap
switch fd.MapKey().Kind() { switch fd.MapKey().Kind() {
case pref.StringKind: case protoreflect.StringKind:
if strs.EnforceUTF8(fd) { if strs.EnforceUTF8(fd) {
vi.keyType = validationTypeUTF8String vi.keyType = validationTypeUTF8String
} }
} }
switch fd.MapValue().Kind() { switch fd.MapValue().Kind() {
case pref.MessageKind: case protoreflect.MessageKind:
vi.valType = validationTypeMessage vi.valType = validationTypeMessage
if ft.Kind() == reflect.Map { if ft.Kind() == reflect.Map {
vi.mi = getMessageInfo(ft.Elem()) vi.mi = getMessageInfo(ft.Elem())
} }
case pref.StringKind: case protoreflect.StringKind:
if strs.EnforceUTF8(fd) { if strs.EnforceUTF8(fd) {
vi.valType = validationTypeUTF8String vi.valType = validationTypeUTF8String
} }
} }
default: default:
switch fd.Kind() { switch fd.Kind() {
case pref.MessageKind: case protoreflect.MessageKind:
vi.typ = validationTypeMessage vi.typ = validationTypeMessage
if !fd.IsWeak() { if !fd.IsWeak() {
vi.mi = getMessageInfo(ft) vi.mi = getMessageInfo(ft)
} }
case pref.GroupKind: case protoreflect.GroupKind:
vi.typ = validationTypeGroup vi.typ = validationTypeGroup
vi.mi = getMessageInfo(ft) vi.mi = getMessageInfo(ft)
case pref.StringKind: case protoreflect.StringKind:
vi.typ = validationTypeBytes vi.typ = validationTypeBytes
if strs.EnforceUTF8(fd) { if strs.EnforceUTF8(fd) {
vi.typ = validationTypeUTF8String vi.typ = validationTypeUTF8String
@ -314,11 +314,11 @@ State:
break break
} }
messageName := fd.Message().FullName() messageName := fd.Message().FullName()
messageType, err := preg.GlobalTypes.FindMessageByName(messageName) messageType, err := protoregistry.GlobalTypes.FindMessageByName(messageName)
switch err { switch err {
case nil: case nil:
vi.mi, _ = messageType.(*MessageInfo) vi.mi, _ = messageType.(*MessageInfo)
case preg.NotFound: case protoregistry.NotFound:
vi.typ = validationTypeBytes vi.typ = validationTypeBytes
default: default:
return out, ValidationUnknown return out, ValidationUnknown
@ -335,7 +335,7 @@ State:
// unmarshaling to begin failing. Supporting this requires some way to // unmarshaling to begin failing. Supporting this requires some way to
// determine if the resolver is frozen. // determine if the resolver is frozen.
xt, err := opts.resolver.FindExtensionByNumber(st.mi.Desc.FullName(), num) xt, err := opts.resolver.FindExtensionByNumber(st.mi.Desc.FullName(), num)
if err != nil && err != preg.NotFound { if err != nil && err != protoregistry.NotFound {
return out, ValidationUnknown return out, ValidationUnknown
} }
if err == nil { if err == nil {
@ -513,7 +513,7 @@ State:
} }
xt, err := opts.resolver.FindExtensionByNumber(st.mi.Desc.FullName(), typeid) xt, err := opts.resolver.FindExtensionByNumber(st.mi.Desc.FullName(), typeid)
switch { switch {
case err == preg.NotFound: case err == protoregistry.NotFound:
b = b[n:] b = b[n:]
case err != nil: case err != nil:
return out, ValidationUnknown return out, ValidationUnknown

View File

@ -7,7 +7,7 @@ package impl
import ( import (
"fmt" "fmt"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry" "google.golang.org/protobuf/reflect/protoregistry"
) )
@ -17,32 +17,32 @@ import (
// defined directly on it. // defined directly on it.
type weakFields WeakFields type weakFields WeakFields
func (w weakFields) get(num pref.FieldNumber) (pref.ProtoMessage, bool) { func (w weakFields) get(num protoreflect.FieldNumber) (protoreflect.ProtoMessage, bool) {
m, ok := w[int32(num)] m, ok := w[int32(num)]
return m, ok return m, ok
} }
func (w *weakFields) set(num pref.FieldNumber, m pref.ProtoMessage) { func (w *weakFields) set(num protoreflect.FieldNumber, m protoreflect.ProtoMessage) {
if *w == nil { if *w == nil {
*w = make(weakFields) *w = make(weakFields)
} }
(*w)[int32(num)] = m (*w)[int32(num)] = m
} }
func (w *weakFields) clear(num pref.FieldNumber) { func (w *weakFields) clear(num protoreflect.FieldNumber) {
delete(*w, int32(num)) delete(*w, int32(num))
} }
func (Export) HasWeak(w WeakFields, num pref.FieldNumber) bool { func (Export) HasWeak(w WeakFields, num protoreflect.FieldNumber) bool {
_, ok := w[int32(num)] _, ok := w[int32(num)]
return ok return ok
} }
func (Export) ClearWeak(w *WeakFields, num pref.FieldNumber) { func (Export) ClearWeak(w *WeakFields, num protoreflect.FieldNumber) {
delete(*w, int32(num)) delete(*w, int32(num))
} }
func (Export) GetWeak(w WeakFields, num pref.FieldNumber, name pref.FullName) pref.ProtoMessage { func (Export) GetWeak(w WeakFields, num protoreflect.FieldNumber, name protoreflect.FullName) protoreflect.ProtoMessage {
if m, ok := w[int32(num)]; ok { if m, ok := w[int32(num)]; ok {
return m return m
} }
@ -53,7 +53,7 @@ func (Export) GetWeak(w WeakFields, num pref.FieldNumber, name pref.FullName) pr
return mt.Zero().Interface() return mt.Zero().Interface()
} }
func (Export) SetWeak(w *WeakFields, num pref.FieldNumber, name pref.FullName, m pref.ProtoMessage) { func (Export) SetWeak(w *WeakFields, num protoreflect.FieldNumber, name protoreflect.FullName, m protoreflect.ProtoMessage) {
if m != nil { if m != nil {
mt, _ := protoregistry.GlobalTypes.FindMessageByName(name) mt, _ := protoregistry.GlobalTypes.FindMessageByName(name)
if mt == nil { if mt == nil {

View File

@ -5,12 +5,12 @@
package order package order
import ( import (
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
// FieldOrder specifies the ordering to visit message fields. // FieldOrder specifies the ordering to visit message fields.
// It is a function that reports whether x is ordered before y. // It is a function that reports whether x is ordered before y.
type FieldOrder func(x, y pref.FieldDescriptor) bool type FieldOrder func(x, y protoreflect.FieldDescriptor) bool
var ( var (
// AnyFieldOrder specifies no specific field ordering. // AnyFieldOrder specifies no specific field ordering.
@ -18,9 +18,9 @@ var (
// LegacyFieldOrder sorts fields in the same ordering as emitted by // LegacyFieldOrder sorts fields in the same ordering as emitted by
// wire serialization in the github.com/golang/protobuf implementation. // wire serialization in the github.com/golang/protobuf implementation.
LegacyFieldOrder FieldOrder = func(x, y pref.FieldDescriptor) bool { LegacyFieldOrder FieldOrder = func(x, y protoreflect.FieldDescriptor) bool {
ox, oy := x.ContainingOneof(), y.ContainingOneof() ox, oy := x.ContainingOneof(), y.ContainingOneof()
inOneof := func(od pref.OneofDescriptor) bool { inOneof := func(od protoreflect.OneofDescriptor) bool {
return od != nil && !od.IsSynthetic() return od != nil && !od.IsSynthetic()
} }
@ -41,14 +41,14 @@ var (
} }
// NumberFieldOrder sorts fields by their field number. // NumberFieldOrder sorts fields by their field number.
NumberFieldOrder FieldOrder = func(x, y pref.FieldDescriptor) bool { NumberFieldOrder FieldOrder = func(x, y protoreflect.FieldDescriptor) bool {
return x.Number() < y.Number() return x.Number() < y.Number()
} }
// IndexNameFieldOrder sorts non-extension fields before extension fields. // IndexNameFieldOrder sorts non-extension fields before extension fields.
// Non-extensions are sorted according to their declaration index. // Non-extensions are sorted according to their declaration index.
// Extensions are sorted according to their full name. // Extensions are sorted according to their full name.
IndexNameFieldOrder FieldOrder = func(x, y pref.FieldDescriptor) bool { IndexNameFieldOrder FieldOrder = func(x, y protoreflect.FieldDescriptor) bool {
// Non-extension fields sort before extension fields. // Non-extension fields sort before extension fields.
if x.IsExtension() != y.IsExtension() { if x.IsExtension() != y.IsExtension() {
return !x.IsExtension() && y.IsExtension() return !x.IsExtension() && y.IsExtension()
@ -64,7 +64,7 @@ var (
// KeyOrder specifies the ordering to visit map entries. // KeyOrder specifies the ordering to visit map entries.
// It is a function that reports whether x is ordered before y. // It is a function that reports whether x is ordered before y.
type KeyOrder func(x, y pref.MapKey) bool type KeyOrder func(x, y protoreflect.MapKey) bool
var ( var (
// AnyKeyOrder specifies no specific key ordering. // AnyKeyOrder specifies no specific key ordering.
@ -72,7 +72,7 @@ var (
// GenericKeyOrder sorts false before true, numeric keys in ascending order, // GenericKeyOrder sorts false before true, numeric keys in ascending order,
// and strings in lexicographical ordering according to UTF-8 codepoints. // and strings in lexicographical ordering according to UTF-8 codepoints.
GenericKeyOrder KeyOrder = func(x, y pref.MapKey) bool { GenericKeyOrder KeyOrder = func(x, y protoreflect.MapKey) bool {
switch x.Interface().(type) { switch x.Interface().(type) {
case bool: case bool:
return !x.Bool() && y.Bool() return !x.Bool() && y.Bool()

View File

@ -9,12 +9,12 @@ import (
"sort" "sort"
"sync" "sync"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
type messageField struct { type messageField struct {
fd pref.FieldDescriptor fd protoreflect.FieldDescriptor
v pref.Value v protoreflect.Value
} }
var messageFieldPool = sync.Pool{ var messageFieldPool = sync.Pool{
@ -26,7 +26,7 @@ type (
// The protoreflect.Message type implements this interface. // The protoreflect.Message type implements this interface.
FieldRanger interface{ Range(VisitField) } FieldRanger interface{ Range(VisitField) }
// VisitField is called every time a message field is visited. // VisitField is called every time a message field is visited.
VisitField = func(pref.FieldDescriptor, pref.Value) bool VisitField = func(protoreflect.FieldDescriptor, protoreflect.Value) bool
) )
// RangeFields iterates over the fields of fs according to the specified order. // RangeFields iterates over the fields of fs according to the specified order.
@ -47,7 +47,7 @@ func RangeFields(fs FieldRanger, less FieldOrder, fn VisitField) {
}() }()
// Collect all fields in the message and sort them. // Collect all fields in the message and sort them.
fs.Range(func(fd pref.FieldDescriptor, v pref.Value) bool { fs.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
fields = append(fields, messageField{fd, v}) fields = append(fields, messageField{fd, v})
return true return true
}) })
@ -64,8 +64,8 @@ func RangeFields(fs FieldRanger, less FieldOrder, fn VisitField) {
} }
type mapEntry struct { type mapEntry struct {
k pref.MapKey k protoreflect.MapKey
v pref.Value v protoreflect.Value
} }
var mapEntryPool = sync.Pool{ var mapEntryPool = sync.Pool{
@ -77,7 +77,7 @@ type (
// The protoreflect.Map type implements this interface. // The protoreflect.Map type implements this interface.
EntryRanger interface{ Range(VisitEntry) } EntryRanger interface{ Range(VisitEntry) }
// VisitEntry is called every time a map entry is visited. // VisitEntry is called every time a map entry is visited.
VisitEntry = func(pref.MapKey, pref.Value) bool VisitEntry = func(protoreflect.MapKey, protoreflect.Value) bool
) )
// RangeEntries iterates over the entries of es according to the specified order. // RangeEntries iterates over the entries of es according to the specified order.
@ -98,7 +98,7 @@ func RangeEntries(es EntryRanger, less KeyOrder, fn VisitEntry) {
}() }()
// Collect all entries in the map and sort them. // Collect all entries in the map and sort them.
es.Range(func(k pref.MapKey, v pref.Value) bool { es.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
entries = append(entries, mapEntry{k, v}) entries = append(entries, mapEntry{k, v})
return true return true
}) })

View File

@ -10,7 +10,7 @@ package strs
import ( import (
"unsafe" "unsafe"
pref "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoreflect"
) )
type ( type (
@ -59,7 +59,7 @@ type Builder struct {
// AppendFullName is equivalent to protoreflect.FullName.Append, // AppendFullName is equivalent to protoreflect.FullName.Append,
// but optimized for large batches where each name has a shared lifetime. // but optimized for large batches where each name has a shared lifetime.
func (sb *Builder) AppendFullName(prefix pref.FullName, name pref.Name) pref.FullName { func (sb *Builder) AppendFullName(prefix protoreflect.FullName, name protoreflect.Name) protoreflect.FullName {
n := len(prefix) + len(".") + len(name) n := len(prefix) + len(".") + len(name)
if len(prefix) == 0 { if len(prefix) == 0 {
n -= len(".") n -= len(".")
@ -68,7 +68,7 @@ func (sb *Builder) AppendFullName(prefix pref.FullName, name pref.Name) pref.Ful
sb.buf = append(sb.buf, prefix...) sb.buf = append(sb.buf, prefix...)
sb.buf = append(sb.buf, '.') sb.buf = append(sb.buf, '.')
sb.buf = append(sb.buf, name...) sb.buf = append(sb.buf, name...)
return pref.FullName(sb.last(n)) return protoreflect.FullName(sb.last(n))
} }
// MakeString is equivalent to string(b), but optimized for large batches // MakeString is equivalent to string(b), but optimized for large batches

View File

@ -12,16 +12,15 @@ import (
// These constants determine the current version of this module. // These constants determine the current version of this module.
// //
//
// For our release process, we enforce the following rules: // For our release process, we enforce the following rules:
// * Tagged releases use a tag that is identical to String. // - Tagged releases use a tag that is identical to String.
// * Tagged releases never reference a commit where the String // - Tagged releases never reference a commit where the String
// contains "devel". // contains "devel".
// * The set of all commits in this repository where String // - The set of all commits in this repository where String
// does not contain "devel" must have a unique String. // does not contain "devel" must have a unique String.
// //
//
// Steps for tagging a new release: // Steps for tagging a new release:
//
// 1. Create a new CL. // 1. Create a new CL.
// //
// 2. Update Minor, Patch, and/or PreRelease as necessary. // 2. Update Minor, Patch, and/or PreRelease as necessary.
@ -53,13 +52,14 @@ import (
const ( const (
Major = 1 Major = 1
Minor = 28 Minor = 28
Patch = 0 Patch = 1
PreRelease = "" PreRelease = ""
) )
// String formats the version string for this module in semver format. // String formats the version string for this module in semver format.
// //
// Examples: // Examples:
//
// v1.20.1 // v1.20.1
// v1.21.0-rc.1 // v1.21.0-rc.1
func String() string { func String() string {

Some files were not shown because too many files have changed in this diff Show More