reflect/protoreflect: remove KnownFields and UnknownFields interfaces

This is a breaking change in light of new methods added in CL/175458.

This removes:
	Message.KnownFields: equivalent functionality have been hoisted up
		to the Message interface itself.
	Message.UnknownFields: equivalent functionality is via
		the Message.{Set,Get}Unknown methods.

Change-Id: Ia08b26894d2b45033a6ad6616258ff0fb9f8b7a4
Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/182597
Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>

internal/impl/message.go

@@ -45,9 +45,7 @@ type MessageInfo struct {
 
 	extensionMap func(pointer) *extensionMap
 
-	unknownFields   func(*messageDataType) pref.UnknownFields
-	extensionFields func(*messageDataType) pref.KnownFields
-	methods         piface.Methods
+	methods piface.Methods
 
 	sizecacheOffset       offset
 	extensionOffset       offset
@@ -246,8 +244,6 @@ func (mi *MessageInfo) makeKnownFieldsFunc(si structInfo) {
 }
 
 func (mi *MessageInfo) makeUnknownFieldsFunc(t reflect.Type) {
-	mi.unknownFields = makeLegacyUnknownFieldsFunc(t)
-
 	mi.getUnknown = func(pointer) pref.RawFields { return nil }
 	mi.setUnknown = func(pointer, pref.RawFields) { return }
 	fu, _ := t.FieldByName("XXX_unrecognized")
@@ -280,8 +276,6 @@ func (mi *MessageInfo) makeUnknownFieldsFunc(t reflect.Type) {
 }
 
 func (mi *MessageInfo) makeExtensionFieldsFunc(t reflect.Type) {
-	mi.extensionFields = makeLegacyExtensionFieldsFunc(t)
-
 	fx, _ := t.FieldByName("XXX_extensions")
 	if fx.Type != extensionFieldsType {
 		fx, _ = t.FieldByName("XXX_InternalExtensions")

internal/impl/message_deprecated.go

@@ -1,143 +0,0 @@
-// Copyright 2018 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 impl
-
-import (
-	"fmt"
-
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// TODO: Remove this file.
-
-// TODO: Remove this.
-func (m *messageReflectWrapper) KnownFields() pref.KnownFields {
-	m.mi.init()
-	return (*knownFields)(m)
-}
-
-// TODO: Remove this.
-func (m *messageReflectWrapper) UnknownFields() pref.UnknownFields {
-	m.mi.init()
-	return m.mi.unknownFields((*messageDataType)(m))
-}
-
-// TODO: Remove this.
-type knownFields messageDataType
-
-func (fs *knownFields) Len() (cnt int) {
-	for _, fi := range fs.mi.fields {
-		if fi.has(fs.p) {
-			cnt++
-		}
-	}
-	return cnt + fs.extensionFields().Len()
-}
-func (fs *knownFields) Has(n pref.FieldNumber) bool {
-	if fi := fs.mi.fields[n]; fi != nil {
-		return fi.has(fs.p)
-	}
-	return fs.extensionFields().Has(n)
-}
-func (fs *knownFields) Get(n pref.FieldNumber) pref.Value {
-	if fi := fs.mi.fields[n]; fi != nil {
-		if !fi.has(fs.p) && isComposite(fi.fieldDesc) {
-			if fi.newMessage != nil {
-				return pref.Value{}
-			}
-			if !fs.p.IsNil() {
-				return fi.mutable(fs.p)
-			}
-		}
-		return fi.get(fs.p)
-	}
-	return fs.extensionFields().Get(n)
-}
-func (fs *knownFields) Set(n pref.FieldNumber, v pref.Value) {
-	if fi := fs.mi.fields[n]; fi != nil {
-		fi.set(fs.p, v)
-		return
-	}
-	if fs.mi.PBType.Descriptor().ExtensionRanges().Has(n) {
-		fs.extensionFields().Set(n, v)
-		return
-	}
-	panic(fmt.Sprintf("invalid field: %d", n))
-}
-func (fs *knownFields) Clear(n pref.FieldNumber) {
-	if fi := fs.mi.fields[n]; fi != nil {
-		fi.clear(fs.p)
-		return
-	}
-	if fs.mi.PBType.Descriptor().ExtensionRanges().Has(n) {
-		fs.extensionFields().Clear(n)
-		return
-	}
-}
-func (fs *knownFields) WhichOneof(s pref.Name) pref.FieldNumber {
-	if oi := fs.mi.oneofs[s]; oi != nil {
-		return oi.which(fs.p)
-	}
-	return 0
-}
-func (fs *knownFields) Range(f func(pref.FieldNumber, pref.Value) bool) {
-	for n, fi := range fs.mi.fields {
-		if fi.has(fs.p) {
-			if !f(n, fi.get(fs.p)) {
-				return
-			}
-		}
-	}
-	fs.extensionFields().Range(f)
-}
-func (fs *knownFields) NewMessage(n pref.FieldNumber) pref.Message {
-	if fi := fs.mi.fields[n]; fi != nil {
-		return fi.newMessage()
-	}
-	if fs.mi.PBType.Descriptor().ExtensionRanges().Has(n) {
-		return fs.extensionFields().NewMessage(n)
-	}
-	panic(fmt.Sprintf("invalid field: %d", n))
-}
-func (fs *knownFields) ExtensionTypes() pref.ExtensionFieldTypes {
-	return fs.extensionFields().ExtensionTypes()
-}
-func (fs *knownFields) extensionFields() pref.KnownFields {
-	return fs.mi.extensionFields((*messageDataType)(fs))
-}
-
-// TODO: Remove this.
-type emptyUnknownFields struct{}
-
-func (emptyUnknownFields) Len() int                                          { return 0 }
-func (emptyUnknownFields) Get(pref.FieldNumber) pref.RawFields               { return nil }
-func (emptyUnknownFields) Set(pref.FieldNumber, pref.RawFields)              { return } // noop
-func (emptyUnknownFields) Range(func(pref.FieldNumber, pref.RawFields) bool) { return }
-func (emptyUnknownFields) IsSupported() bool                                 { return false }
-
-// TODO: Remove this.
-type emptyExtensionFields struct{}
-
-func (emptyExtensionFields) Len() int                                      { return 0 }
-func (emptyExtensionFields) Has(pref.FieldNumber) bool                     { return false }
-func (emptyExtensionFields) Get(pref.FieldNumber) pref.Value               { return pref.Value{} }
-func (emptyExtensionFields) Set(pref.FieldNumber, pref.Value)              { panic("extensions not supported") }
-func (emptyExtensionFields) Clear(pref.FieldNumber)                        { return } // noop
-func (emptyExtensionFields) WhichOneof(pref.Name) pref.FieldNumber         { return 0 }
-func (emptyExtensionFields) Range(func(pref.FieldNumber, pref.Value) bool) { return }
-func (emptyExtensionFields) NewMessage(pref.FieldNumber) pref.Message {
-	panic("extensions not supported")
-}
-func (emptyExtensionFields) ExtensionTypes() pref.ExtensionFieldTypes { return emptyExtensionTypes{} }
-
-// TODO: Remove this.
-type emptyExtensionTypes struct{}
-
-func (emptyExtensionTypes) Len() int                                     { return 0 }
-func (emptyExtensionTypes) Register(pref.ExtensionType)                  { panic("extensions not supported") }
-func (emptyExtensionTypes) Remove(pref.ExtensionType)                    { return } // noop
-func (emptyExtensionTypes) ByNumber(pref.FieldNumber) pref.ExtensionType { return nil }
-func (emptyExtensionTypes) ByName(pref.FullName) pref.ExtensionType      { return nil }
-func (emptyExtensionTypes) Range(func(pref.ExtensionType) bool)          { return }

internal/impl/message_field_extension.go

@@ -1,254 +0,0 @@
-// Copyright 2018 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 impl
-
-import (
-	"reflect"
-
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// TODO: Remove this file.
-
-var extType = reflect.TypeOf(map[int32]ExtensionField(nil))
-
-func makeLegacyExtensionFieldsFunc(t reflect.Type) func(p *messageDataType) pref.KnownFields {
-	f := makeLegacyExtensionMapFunc(t)
-	if f == nil {
-		return func(*messageDataType) pref.KnownFields {
-			return emptyExtensionFields{}
-		}
-	}
-	return func(p *messageDataType) pref.KnownFields {
-		if p.p.IsNil() {
-			return emptyExtensionFields{}
-		}
-		return legacyExtensionFields{p.mi, f(p)}
-	}
-}
-
-func makeLegacyExtensionMapFunc(t reflect.Type) func(*messageDataType) *legacyExtensionMap {
-	fx, _ := t.FieldByName("XXX_extensions")
-	if fx.Type != extType {
-		fx, _ = t.FieldByName("XXX_InternalExtensions")
-	}
-	if fx.Type != extType {
-		return nil
-	}
-
-	fieldOffset := offsetOf(fx)
-	return func(p *messageDataType) *legacyExtensionMap {
-		v := p.p.Apply(fieldOffset).AsValueOf(fx.Type).Interface()
-		return (*legacyExtensionMap)(v.(*map[int32]ExtensionField))
-	}
-}
-
-type legacyExtensionFields struct {
-	mi *MessageInfo
-	x  *legacyExtensionMap
-}
-
-func (p legacyExtensionFields) Len() (n int) {
-	p.x.Range(func(num pref.FieldNumber, _ ExtensionField) bool {
-		if p.Has(pref.FieldNumber(num)) {
-			n++
-		}
-		return true
-	})
-	return n
-}
-
-func (p legacyExtensionFields) Has(n pref.FieldNumber) bool {
-	x := p.x.Get(n)
-	if !x.HasValue() {
-		return false
-	}
-	t := x.GetType()
-	d := t.Descriptor()
-	if d.IsList() {
-		return t.ValueOf(x.GetValue()).List().Len() > 0
-	}
-	return true
-}
-
-func (p legacyExtensionFields) Get(n pref.FieldNumber) pref.Value {
-	x := p.x.Get(n)
-	if !x.HasType() {
-		return pref.Value{}
-	}
-	t := x.GetType()
-	d := t.Descriptor()
-	if !x.HasValue() {
-		// NOTE: x.Value is never nil for Lists since they are always populated
-		// during ExtensionFieldTypes.Register.
-		if d.Kind() == pref.MessageKind || d.Kind() == pref.GroupKind {
-			return pref.Value{}
-		}
-		return d.Default()
-	}
-	return t.ValueOf(x.GetValue())
-}
-
-func (p legacyExtensionFields) Set(n pref.FieldNumber, v pref.Value) {
-	x := p.x.Get(n)
-	if !x.HasType() {
-		panic("no extension descriptor registered")
-	}
-	t := x.GetType()
-	x.SetEagerValue(t.InterfaceOf(v))
-	p.x.Set(n, x)
-}
-
-func (p legacyExtensionFields) Clear(n pref.FieldNumber) {
-	x := p.x.Get(n)
-	if !x.HasType() {
-		return
-	}
-	t := x.GetType()
-	d := t.Descriptor()
-	if d.IsList() {
-		t.ValueOf(x.GetValue()).List().Truncate(0)
-		return
-	}
-	x.SetEagerValue(nil)
-	p.x.Set(n, x)
-}
-
-func (p legacyExtensionFields) WhichOneof(pref.Name) pref.FieldNumber {
-	return 0
-}
-
-func (p legacyExtensionFields) Range(f func(pref.FieldNumber, pref.Value) bool) {
-	p.x.Range(func(n pref.FieldNumber, x ExtensionField) bool {
-		if p.Has(n) {
-			return f(n, p.Get(n))
-		}
-		return true
-	})
-}
-
-func (p legacyExtensionFields) NewMessage(n pref.FieldNumber) pref.Message {
-	x := p.x.Get(n)
-	if !x.HasType() {
-		panic("no extension descriptor registered")
-	}
-	xt := x.GetType()
-	return xt.New().Message()
-}
-
-func (p legacyExtensionFields) ExtensionTypes() pref.ExtensionFieldTypes {
-	return legacyExtensionTypes(p)
-}
-
-type legacyExtensionTypes legacyExtensionFields
-
-func (p legacyExtensionTypes) Len() (n int) {
-	p.x.Range(func(_ pref.FieldNumber, x ExtensionField) bool {
-		if x.HasType() {
-			n++
-		}
-		return true
-	})
-	return n
-}
-
-func (p legacyExtensionTypes) Register(t pref.ExtensionType) {
-	d := t.Descriptor()
-	if p.mi.PBType.Descriptor().FullName() != d.ContainingMessage().FullName() {
-		panic("extended type mismatch")
-	}
-	if !p.mi.PBType.Descriptor().ExtensionRanges().Has(d.Number()) {
-		panic("invalid extension field number")
-	}
-	x := p.x.Get(d.Number())
-	if x.HasType() {
-		panic("extension descriptor already registered")
-	}
-	x.SetType(t)
-	if d.IsList() {
-		// If the field is repeated, initialize the entry with an empty list
-		// so that future Get operations can return a mutable and concrete list.
-		x.SetEagerValue(t.InterfaceOf(t.New()))
-	}
-	p.x.Set(d.Number(), x)
-}
-
-func (p legacyExtensionTypes) Remove(t pref.ExtensionType) {
-	d := t.Descriptor()
-	if !p.mi.PBType.Descriptor().ExtensionRanges().Has(d.Number()) {
-		return
-	}
-	x := p.x.Get(d.Number())
-	if d.IsList() {
-		// Treat an empty repeated field as unpopulated.
-		v := reflect.ValueOf(x.GetValue())
-		if !x.HasValue() || v.IsNil() || v.Elem().Len() == 0 {
-			x.SetEagerValue(nil)
-		}
-	}
-	if x.GetValue() != nil {
-		panic("value for extension descriptor still populated")
-	}
-	p.x.Clear(d.Number())
-}
-
-func (p legacyExtensionTypes) ByNumber(n pref.FieldNumber) pref.ExtensionType {
-	x := p.x.Get(n)
-	if x.HasType() {
-		return x.GetType()
-	}
-	return nil
-}
-
-func (p legacyExtensionTypes) ByName(s pref.FullName) (t pref.ExtensionType) {
-	p.x.Range(func(_ pref.FieldNumber, x ExtensionField) bool {
-		if x.HasType() && x.GetType().FullName() == s {
-			t = x.GetType()
-			return false
-		}
-		return true
-	})
-	return t
-}
-
-func (p legacyExtensionTypes) Range(f func(pref.ExtensionType) bool) {
-	p.x.Range(func(_ pref.FieldNumber, x ExtensionField) bool {
-		if x.HasType() {
-			if !f(x.GetType()) {
-				return false
-			}
-		}
-		return true
-	})
-}
-
-type legacyExtensionMap map[int32]ExtensionField
-
-func (m legacyExtensionMap) Len() int {
-	return len(m)
-}
-func (m legacyExtensionMap) Has(n pref.FieldNumber) bool {
-	_, ok := m[int32(n)]
-	return ok
-}
-func (m legacyExtensionMap) Get(n pref.FieldNumber) ExtensionField {
-	return m[int32(n)]
-}
-func (m *legacyExtensionMap) Set(n pref.FieldNumber, x ExtensionField) {
-	if *m == nil {
-		*m = make(map[int32]ExtensionField)
-	}
-	(*m)[int32(n)] = x
-}
-func (m *legacyExtensionMap) Clear(n pref.FieldNumber) {
-	delete(*m, int32(n))
-}
-func (m legacyExtensionMap) Range(f func(pref.FieldNumber, ExtensionField) bool) {
-	for n, x := range m {
-		if !f(pref.FieldNumber(n), x) {
-			return
-		}
-	}
-}

internal/impl/message_field_unknown.go

@@ -1,133 +0,0 @@
-// Copyright 2018 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 impl
-
-import (
-	"container/list"
-	"reflect"
-
-	"google.golang.org/protobuf/internal/encoding/wire"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// TODO: Remove this file.
-
-var bytesType = reflect.TypeOf([]byte(nil))
-
-func makeLegacyUnknownFieldsFunc(t reflect.Type) func(p *messageDataType) pref.UnknownFields {
-	fu, ok := t.FieldByName("XXX_unrecognized")
-	if !ok || fu.Type != bytesType {
-		return func(*messageDataType) pref.UnknownFields {
-			return emptyUnknownFields{}
-		}
-	}
-	fieldOffset := offsetOf(fu)
-	return func(p *messageDataType) pref.UnknownFields {
-		if p.p.IsNil() {
-			return emptyUnknownFields{}
-		}
-		rv := p.p.Apply(fieldOffset).AsValueOf(bytesType)
-		return (*legacyUnknownBytes)(rv.Interface().(*[]byte))
-	}
-}
-
-// legacyUnknownBytes is a wrapper around XXX_unrecognized that implements
-// the protoreflect.UnknownFields interface. This is challenging since we are
-// limited to a []byte, so we do not have much flexibility in the choice
-// of data structure that would have been ideal.
-type legacyUnknownBytes []byte
-
-func (fs *legacyUnknownBytes) Len() int {
-	// Runtime complexity: O(n)
-	b := *fs
-	m := map[pref.FieldNumber]bool{}
-	for len(b) > 0 {
-		num, _, n := wire.ConsumeField(b)
-		m[num] = true
-		b = b[n:]
-	}
-	return len(m)
-}
-
-func (fs *legacyUnknownBytes) Get(num pref.FieldNumber) (raw pref.RawFields) {
-	// Runtime complexity: O(n)
-	b := *fs
-	for len(b) > 0 {
-		num2, _, n := wire.ConsumeField(b)
-		if num == num2 {
-			raw = append(raw, b[:n]...)
-		}
-		b = b[n:]
-	}
-	return raw
-}
-
-func (fs *legacyUnknownBytes) Set(num pref.FieldNumber, raw pref.RawFields) {
-	num2, _, _ := wire.ConsumeTag(raw)
-	if len(raw) > 0 && (!raw.IsValid() || num != num2) {
-		panic("invalid raw fields")
-	}
-
-	// Remove all current fields of num.
-	// Runtime complexity: O(n)
-	b := *fs
-	out := (*fs)[:0]
-	for len(b) > 0 {
-		num2, _, n := wire.ConsumeField(b)
-		if num != num2 {
-			out = append(out, b[:n]...)
-		}
-		b = b[n:]
-	}
-	*fs = out
-
-	// Append new fields of num.
-	*fs = append(*fs, raw...)
-}
-
-func (fs *legacyUnknownBytes) Range(f func(pref.FieldNumber, pref.RawFields) bool) {
-	type entry struct {
-		num pref.FieldNumber
-		raw pref.RawFields
-	}
-
-	// Collect up a list of all the raw fields.
-	// We preserve the order such that the latest encountered fields
-	// are presented at the end.
-	//
-	// Runtime complexity: O(n)
-	b := *fs
-	l := list.New()
-	m := map[pref.FieldNumber]*list.Element{}
-	for len(b) > 0 {
-		num, _, n := wire.ConsumeField(b)
-		if e, ok := m[num]; ok {
-			x := e.Value.(*entry)
-			x.raw = append(x.raw, b[:n]...)
-			l.MoveToBack(e)
-		} else {
-			x := &entry{num: num}
-			x.raw = append(x.raw, b[:n]...)
-			m[num] = l.PushBack(x)
-		}
-		b = b[n:]
-	}
-
-	// Iterate over all the raw fields.
-	// This ranges over a snapshot of the current state such that mutations
-	// while ranging are not observable.
-	//
-	// Runtime complexity: O(n)
-	for e := l.Front(); e != nil; e = e.Next() {
-		x := e.Value.(*entry)
-		if !f(x.num, x.raw) {
-			return
-		}
-	}
-}
-
-func (fs *legacyUnknownBytes) IsSupported() bool {
-	return true
-}

internal/testprotos/irregular/irregular_deprecated.go

@@ -1,93 +0,0 @@
-// Copyright 2019 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 irregular
-
-import (
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-func (m *message) KnownFields() pref.KnownFields     { return (*known)(m) }
-func (m *message) UnknownFields() pref.UnknownFields { return (*unknown)(m) }
-
-type known IrregularMessage
-
-func (m *known) Len() int {
-	if m.set {
-		return 1
-	}
-	return 0
-}
-
-func (m *known) Has(num pref.FieldNumber) bool {
-	switch num {
-	case fieldS:
-		return m.set
-	}
-	return false
-}
-
-func (m *known) Get(num pref.FieldNumber) pref.Value {
-	switch num {
-	case fieldS:
-		return pref.ValueOf(m.value)
-	}
-	return pref.Value{}
-}
-
-func (m *known) Set(num pref.FieldNumber, v pref.Value) {
-	switch num {
-	case fieldS:
-		m.value = v.String()
-	default:
-		panic("unknown field")
-	}
-}
-
-func (m *known) Clear(num pref.FieldNumber) {
-	switch num {
-	case fieldS:
-		m.value = ""
-		m.set = false
-	default:
-		panic("unknown field")
-	}
-}
-
-func (m *known) WhichOneof(name pref.Name) pref.FieldNumber {
-	return 0
-}
-
-func (m *known) Range(f func(pref.FieldNumber, pref.Value) bool) {
-	if m.set {
-		f(fieldS, pref.ValueOf(m.value))
-	}
-}
-
-func (m *known) NewMessage(num pref.FieldNumber) pref.Message {
-	panic("not a message field")
-}
-
-func (m *known) ExtensionTypes() pref.ExtensionFieldTypes {
-	return (*exttypes)(m)
-}
-
-const fieldS = pref.FieldNumber(1)
-
-type unknown IrregularMessage
-
-func (m *unknown) Len() int                                          { return 0 }
-func (m *unknown) Get(pref.FieldNumber) pref.RawFields               { return nil }
-func (m *unknown) Set(pref.FieldNumber, pref.RawFields)              {}
-func (m *unknown) Range(func(pref.FieldNumber, pref.RawFields) bool) {}
-func (m *unknown) IsSupported() bool                                 { return false }
-
-type exttypes IrregularMessage
-
-func (m *exttypes) Len() int                                     { return 0 }
-func (m *exttypes) Register(pref.ExtensionType)                  { panic("not extendable") }
-func (m *exttypes) Remove(pref.ExtensionType)                    {}
-func (m *exttypes) ByNumber(pref.FieldNumber) pref.ExtensionType { return nil }
-func (m *exttypes) ByName(pref.FullName) pref.ExtensionType      { return nil }
-func (m *exttypes) Range(func(pref.ExtensionType) bool)          {}

reflect/protoreflect/deprecated.go

@@ -1,179 +0,0 @@
-// Copyright 2019 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 protoreflect
-
-// TODO: Remove this file.
-
-type (
-	deprecatedMessage interface {
-		// Deprecated: Use methods on Message directly.
-		KnownFields() KnownFields
-		// Deprecated: Use methods on Message directly.
-		UnknownFields() UnknownFields
-	}
-)
-
-// KnownFields provides accessor and mutator methods for known fields.
-//
-// Each field Value can either be a scalar, Message, List, or Map.
-// The field is a List or Map if FieldDescriptor.Cardinality is Repeated and
-// a Map if and only if FieldDescriptor.IsMap is true. The scalar type or
-// underlying repeated element type is determined by the FieldDescriptor.Kind.
-// See Value for a list of Go types associated with each Kind.
-//
-// Field extensions are handled as known fields once the extension type has been
-// registered with KnownFields.ExtensionTypes.
-//
-// Len, Has, Get, Range, and ExtensionTypes are safe for concurrent use.
-//
-// Deprecated: Use direct methods on Message instead.
-type KnownFields interface {
-	// Len reports the number of fields that are populated.
-	Len() int
-
-	// Has reports whether a field is populated.
-	//
-	// Some fields have the property of nullability where it is possible to
-	// distinguish between the default value of a field and whether the field
-	// was explicitly populated with the default value. Only scalars in proto2,
-	// member fields of a oneof, and singular messages are nullable.
-	//
-	// A nullable field is populated only if explicitly set.
-	// A scalar field in proto3 is populated if it contains a non-zero value.
-	// A repeated field is populated only if it is non-empty.
-	Has(FieldNumber) bool
-
-	// Get retrieves the value for a field with the given field number.
-	// If the field is unpopulated, it returns the default value for scalars,
-	// a mutable empty List for empty repeated fields, a mutable empty Map for
-	// empty map fields, and an invalid value for message fields.
-	// If the field is unknown (does not appear in MessageDescriptor.Fields
-	// or ExtensionFieldTypes), it returns an invalid value.
-	Get(FieldNumber) Value
-
-	// Set stores the value for a field with the given field number.
-	// Setting a field belonging to a oneof implicitly clears any other field
-	// that may be currently set by the same oneof.
-	//
-	// When setting a composite type, it is unspecified whether the set
-	// value aliases the source's memory in any way.
-	//
-	// It panics if the field number does not correspond with a known field
-	// in MessageDescriptor.Fields or an extension field in ExtensionTypes.
-	Set(FieldNumber, Value)
-
-	// TODO: Document memory aliasing behavior when a field is cleared?
-	// For example, if Mutable is called later, can it reuse memory?
-
-	// Clear clears the field such that a subsequent call to Has reports false.
-	// The operation does nothing if the field number does not correspond with
-	// a known field or extension field.
-	Clear(FieldNumber)
-
-	// WhichOneof reports which field within the named oneof is populated.
-	// It returns 0 if the oneof does not exist or no fields are populated.
-	WhichOneof(Name) FieldNumber
-
-	// Range iterates over every populated field in an undefined order,
-	// calling f for each field number and value encountered.
-	// Range calls f Len times unless f returns false, which stops iteration.
-	// While iterating, mutating operations through Set, Clear, or Mutable
-	// may only be performed on the current field number.
-	Range(f func(FieldNumber, Value) bool)
-
-	// NewMessage returns a newly allocated empty message assignable to
-	// the field of the given number.
-	// It panics if the field is not a singular message.
-	NewMessage(FieldNumber) Message
-
-	// ExtensionTypes are extension field types that are known by this
-	// specific message instance.
-	ExtensionTypes() ExtensionFieldTypes
-}
-
-// UnknownFields are a list of unknown or unparsed fields and may contain
-// field numbers corresponding with defined fields or extension fields.
-// The ordering of fields is maintained for fields of the same field number.
-// However, the relative ordering of fields with different field numbers
-// is undefined.
-//
-// Len, Get, and Range are safe for concurrent use.
-//
-// Deprecated: Use direct methods on Message instead.
-type UnknownFields interface {
-	// Len reports the number of fields that are populated.
-	Len() int
-
-	// Get retrieves the raw bytes of fields with the given field number.
-	// It returns an empty RawFields if there are no populated fields.
-	//
-	// The caller must not mutate the content of the retrieved RawFields.
-	Get(FieldNumber) RawFields
-
-	// Set stores the raw bytes of fields with the given field number.
-	// The RawFields must be valid and correspond with the given field number;
-	// an implementation may panic if the fields are invalid.
-	// An empty RawFields may be passed to clear the fields.
-	//
-	// The caller must not mutate the content of the RawFields being stored.
-	Set(FieldNumber, RawFields)
-
-	// Range iterates over every populated field in an undefined order,
-	// calling f for each field number and raw field value encountered.
-	// Range calls f Len times unless f returns false, which stops iteration.
-	// While iterating, mutating operations through Set may only be performed
-	// on the current field number.
-	//
-	// While the iteration order is undefined, it is deterministic.
-	// It is recommended, but not required, that fields be presented
-	// in the order that they were encountered in the wire data.
-	Range(f func(FieldNumber, RawFields) bool)
-
-	// TODO: Should IsSupported be renamed as ReadOnly?
-	// TODO: Should IsSupported panic on Set instead of silently ignore?
-
-	// IsSupported reports whether this message supports unknown fields.
-	// If false, UnknownFields ignores all Set operations.
-	IsSupported() bool
-}
-
-// ExtensionFieldTypes are the extension field types that this message instance
-// has been extended with.
-//
-// Len, Get, and Range are safe for concurrent use.
-//
-// Deprecated: Use direct methods on Message instead.
-type ExtensionFieldTypes interface {
-	// Len reports the number of field extensions.
-	Len() int
-
-	// Register stores an ExtensionType.
-	// The ExtensionType.ExtendedType must match the containing message type
-	// and the field number must be within the valid extension ranges
-	// (see MessageDescriptor.ExtensionRanges).
-	// It panics if the extension has already been registered (i.e.,
-	// a conflict by number or by full name).
-	Register(ExtensionType)
-
-	// Remove removes the ExtensionType.
-	// It panics if a value for this extension field is still populated.
-	// The operation does nothing if there is no associated type to remove.
-	Remove(ExtensionType)
-
-	// ByNumber looks up an extension by field number.
-	// It returns nil if not found.
-	ByNumber(FieldNumber) ExtensionType
-
-	// ByName looks up an extension field by full name.
-	// It returns nil if not found.
-	ByName(FullName) ExtensionType
-
-	// Range iterates over every registered field in an undefined order,
-	// calling f for each extension descriptor encountered.
-	// Range calls f Len times unless f returns false, which stops iteration.
-	// While iterating, mutating operations through Remove may only
-	// be performed on the current descriptor.
-	Range(f func(ExtensionType) bool)
-}

reflect/protoreflect/value.go

@@ -130,8 +130,6 @@ type Message interface {
 	SetUnknown(RawFields)
 
 	// TODO: Add method to retrieve ExtensionType by FieldNumber?
-
-	deprecatedMessage
 }
 
 // RawFields is the raw bytes for an ordered sequence of fields.