all: rename Vector as List

The terminology Vector does not occur in protobuf documentation at all,
so we should rename the Go use of the term to something more recognizable.
As such, all instances that match the regexp "[Vv]ect(or)?" were replaced.

The C++ documentation uses the term "Repeated", which is a reasonable name.
However, the term became overloaded in 2014, when maps were added as a feature
and implementated under the hood as repeated fields. This is confusing as it
means "repeated" could either refer to repeated fields proper (i.e., explicitly
marked with the "repeated" label in the proto file) or map fields. In the case
of the C++ reflective API, this is not a problem since repeated fields proper
and map fields are interacted with through the same RepeatedField type.

In Go, we do not use a single type to handle both types of repeated fields:
1) We are coming up with the Go protobuf reflection API for the first time
and so do not need to piggy-back on the repeated fields API to remain backwards
compatible since no former usages of Go protobuf reflection exists.
2) Map fields are commonly represented in Go as the Go map type, which do not
preserve ordering information. As such it is fundamentally impossible to present
an unordered map as a consistently ordered list. Thus, Go needs two different
interfaces for lists and maps.

Given the above situation, "Repeated" is not a great term to use since it
refers to two different things (when we only want one of the meanings).
To distinguish between the two, we'll use the terms "List" and "Map" instead.
There is some precedence for the term "List" in the protobuf codebase
(e.g., "getRepeatedInt32List").

Change-Id: Iddcdb6b78e1e60c14fa4ca213c15f45e214b967b
Reviewed-on: https://go-review.googlesource.com/c/149657
Reviewed-by: Damien Neil <dneil@google.com>

internal/impl/legacy_extension.go

@@ -47,7 +47,7 @@ func (p legacyExtensionFields) Has(n pref.FieldNumber) bool {
 	}
 	t := legacyExtensionTypeOf(x.desc)
 	if t.Cardinality() == pref.Repeated {
-		return legacyExtensionValueOf(x.val, t).Vector().Len() > 0
+		return legacyExtensionValueOf(x.val, t).List().Len() > 0
 	}
 	return true
 }
@@ -60,7 +60,7 @@ func (p legacyExtensionFields) Get(n pref.FieldNumber) pref.Value {
 	t := legacyExtensionTypeOf(x.desc)
 	if x.val == nil {
 		if t.Cardinality() == pref.Repeated {
-			// TODO: What is the zero value for Vectors?
+			// TODO: What is the zero value for Lists?
 			// TODO: This logic is racy.
 			v := t.ValueOf(t.New())
 			x.val = legacyExtensionInterfaceOf(v, t)
@@ -305,10 +305,10 @@ func legacyExtensionTypeOf(d *protoV1.ExtensionDesc) pref.ExtensionType {
 			if reflect.TypeOf(v) != xt2.typ {
 				panic(fmt.Sprintf("invalid type: got %T, want %v", v, xt2.typ))
 			}
-			return pref.ValueOf(pvalue.VectorOf(v, conv))
+			return pref.ValueOf(pvalue.ListOf(v, conv))
 		}
 		xt2.interfaceOf = func(pv pref.Value) interface{} {
-			v := pv.Vector().(pvalue.Unwrapper).Unwrap()
+			v := pv.List().(pvalue.Unwrapper).Unwrap()
 			if reflect.TypeOf(v) != xt2.typ {
 				panic(fmt.Sprintf("invalid type: got %T, want %v", v, xt2.typ))
 			}

internal/impl/legacy_test.go

@@ -776,7 +776,7 @@ func TestLegactExtensions(t *testing.T) {
 	}
 
 	// Check that getting the zero value returns the default value for scalars,
-	// nil for singular messages, and an empty vector for repeated fields.
+	// nil for singular messages, and an empty list for repeated fields.
 	defaultValues := []interface{}{
 		bool(true),
 		int32(-12345),
@@ -816,7 +816,7 @@ func TestLegactExtensions(t *testing.T) {
 		}
 	}
 
-	// Set some values and append to values to the vectors.
+	// Set some values and append to values to the lists.
 	m1 := &proto2_20180125.Message_ChildMessage{F1: protoV1.String("m1")}
 	m2 := &proto2_20180125.Message_ChildMessage{F1: protoV1.String("m2")}
 	setValues := []interface{}{
@@ -842,7 +842,7 @@ func TestLegactExtensions(t *testing.T) {
 	}
 	for i, xt := range extensions[len(extensions)/2:] {
 		v := extensions[i].ValueOf(setValues[i])
-		fs.Get(xt.Number()).Vector().Append(v)
+		fs.Get(xt.Number()).List().Append(v)
 	}
 
 	// Get the values and check for equality.

internal/impl/message.go

@@ -132,7 +132,7 @@ fieldLoop:
 		case fd.IsMap():
 			fi = fieldInfoForMap(fd, fs)
 		case fd.Cardinality() == pref.Repeated:
-			fi = fieldInfoForVector(fd, fs)
+			fi = fieldInfoForList(fd, fs)
 		case fd.Kind() == pref.MessageKind || fd.Kind() == pref.GroupKind:
 			fi = fieldInfoForMessage(fd, fs)
 		default:

internal/impl/message_field.go

@@ -134,7 +134,7 @@ func fieldInfoForMap(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo
 	}
 }
 
-func fieldInfoForVector(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo {
+func fieldInfoForList(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo {
 	ft := fs.Type
 	if ft.Kind() != reflect.Slice {
 		panic(fmt.Sprintf("invalid type: got %v, want slice kind", ft))
@@ -149,11 +149,11 @@ func fieldInfoForVector(fd pref.FieldDescriptor, fs reflect.StructField) fieldIn
 		},
 		get: func(p pointer) pref.Value {
 			v := p.apply(fieldOffset).asType(fs.Type).Interface()
-			return pref.ValueOf(pvalue.VectorOf(v, conv))
+			return pref.ValueOf(pvalue.ListOf(v, conv))
 		},
 		set: func(p pointer, v pref.Value) {
 			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
-			rv.Set(reflect.ValueOf(v.Vector().(pvalue.Unwrapper).Unwrap()).Elem())
+			rv.Set(reflect.ValueOf(v.List().(pvalue.Unwrapper).Unwrap()).Elem())
 		},
 		clear: func(p pointer) {
 			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
@@ -161,7 +161,7 @@ func fieldInfoForVector(fd pref.FieldDescriptor, fs reflect.StructField) fieldIn
 		},
 		mutable: func(p pointer) pref.Mutable {
 			v := p.apply(fieldOffset).asType(fs.Type).Interface()
-			return pvalue.VectorOf(v, conv)
+			return pvalue.ListOf(v, conv)
 		},
 	}
 }

internal/impl/message_test.go

@@ -40,20 +40,20 @@ type (
 	MyString  string
 	MyBytes   []byte
 
-	VectorStrings []MyString
-	VectorBytes   []MyBytes
+	ListStrings []MyString
+	ListBytes   []MyBytes
 
 	MapStrings map[MyString]MyString
 	MapBytes   map[MyString]MyBytes
 )
 
-// List of test operations to perform on messages, vectors, or maps.
+// List of test operations to perform on messages, lists, or maps.
 type (
-	messageOp  interface{} // equalMessage | hasFields | getFields | setFields | clearFields | vectorFields | mapFields
+	messageOp  interface{} // equalMessage | hasFields | getFields | setFields | clearFields | listFields | mapFields
 	messageOps []messageOp
 
-	vectorOp  interface{} // equalVector | lenVector | getVector | setVector | appendVector | truncVector
-	vectorOps []vectorOp
+	listOp  interface{} // equalList | lenList | getList | setList | appendList | truncList
+	listOps []listOp
 
 	mapOp  interface{} // equalMap | lenMap | hasMap | getMap | setMap | clearMap | rangeMap
 	mapOps []mapOp
@@ -66,20 +66,20 @@ type (
 	getFields     map[pref.FieldNumber]pref.Value
 	setFields     map[pref.FieldNumber]pref.Value
 	clearFields   map[pref.FieldNumber]bool
-	vectorFields  map[pref.FieldNumber]vectorOps
+	listFields    map[pref.FieldNumber]listOps
 	mapFields     map[pref.FieldNumber]mapOps
 	messageFields map[pref.FieldNumber]messageOps
 	// TODO: Mutable, Range, ExtensionTypes
 )
 
-// Test operations performed on a vector.
+// Test operations performed on a list.
 type (
-	equalVector  pref.Vector
-	lenVector    int
-	getVector    map[int]pref.Value
-	setVector    map[int]pref.Value
-	appendVector []pref.Value
-	truncVector  int
+	equalList  pref.List
+	lenList    int
+	getList    map[int]pref.Value
+	setList    map[int]pref.Value
+	appendList []pref.Value
+	truncList  int
 	// TODO: Mutable, MutableAppend
 )
 
@@ -318,10 +318,10 @@ type ListScalars struct {
 	MyBytes1   []MyBytes  `protobuf:"14"`
 	MyBytes2   []MyString `protobuf:"15"`
 
-	MyStrings3 VectorStrings `protobuf:"16"`
-	MyStrings4 VectorBytes   `protobuf:"17"`
-	MyBytes3   VectorBytes   `protobuf:"18"`
-	MyBytes4   VectorStrings `protobuf:"19"`
+	MyStrings3 ListStrings `protobuf:"16"`
+	MyStrings4 ListBytes   `protobuf:"17"`
+	MyBytes3   ListBytes   `protobuf:"18"`
+	MyBytes4   ListStrings `protobuf:"19"`
 }
 
 var listScalarsType = MessageType{Type: ptype.GoMessage(
@@ -386,10 +386,10 @@ func TestListScalars(t *testing.T) {
 		MyBytes1:   []MyBytes{[]byte("14"), nil, []byte("fourteen")},
 		MyBytes2:   []MyString{"15", "", "fifteen"},
 
-		MyStrings3: VectorStrings{"16", "", "sixteen"},
-		MyStrings4: VectorBytes{[]byte("17"), nil, []byte("seventeen")},
-		MyBytes3:   VectorBytes{[]byte("18"), nil, []byte("eighteen")},
-		MyBytes4:   VectorStrings{"19", "", "nineteen"},
+		MyStrings3: ListStrings{"16", "", "sixteen"},
+		MyStrings4: ListBytes{[]byte("17"), nil, []byte("seventeen")},
+		MyBytes3:   ListBytes{[]byte("18"), nil, []byte("eighteen")},
+		MyBytes4:   ListStrings{"19", "", "nineteen"},
 	}
 	wantFS := want.KnownFields()
 
@@ -397,53 +397,53 @@ func TestListScalars(t *testing.T) {
 		hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false},
 		getFields{1: emptyFS.Get(1), 3: emptyFS.Get(3), 5: emptyFS.Get(5), 7: emptyFS.Get(7), 9: emptyFS.Get(9), 11: emptyFS.Get(11), 13: emptyFS.Get(13), 15: emptyFS.Get(15), 17: emptyFS.Get(17), 19: emptyFS.Get(19)},
 		setFields{1: wantFS.Get(1), 3: wantFS.Get(3), 5: wantFS.Get(5), 7: wantFS.Get(7), 9: wantFS.Get(9), 11: wantFS.Get(11), 13: wantFS.Get(13), 15: wantFS.Get(15), 17: wantFS.Get(17), 19: wantFS.Get(19)},
-		vectorFields{
+		listFields{
 			2: {
-				lenVector(0),
-				appendVector{V(int32(2)), V(int32(math.MinInt32)), V(int32(math.MaxInt32))},
-				getVector{0: V(int32(2)), 1: V(int32(math.MinInt32)), 2: V(int32(math.MaxInt32))},
-				equalVector(wantFS.Get(2).Vector()),
+				lenList(0),
+				appendList{V(int32(2)), V(int32(math.MinInt32)), V(int32(math.MaxInt32))},
+				getList{0: V(int32(2)), 1: V(int32(math.MinInt32)), 2: V(int32(math.MaxInt32))},
+				equalList(wantFS.Get(2).List()),
 			},
 			4: {
-				appendVector{V(uint32(0)), V(uint32(0)), V(uint32(0))},
-				setVector{0: V(uint32(4)), 1: V(uint32(math.MaxUint32 / 2)), 2: V(uint32(math.MaxUint32))},
-				lenVector(3),
+				appendList{V(uint32(0)), V(uint32(0)), V(uint32(0))},
+				setList{0: V(uint32(4)), 1: V(uint32(math.MaxUint32 / 2)), 2: V(uint32(math.MaxUint32))},
+				lenList(3),
 			},
 			6: {
-				appendVector{V(float32(6)), V(float32(math.SmallestNonzeroFloat32)), V(float32(math.NaN())), V(float32(math.MaxFloat32))},
-				equalVector(wantFS.Get(6).Vector()),
+				appendList{V(float32(6)), V(float32(math.SmallestNonzeroFloat32)), V(float32(math.NaN())), V(float32(math.MaxFloat32))},
+				equalList(wantFS.Get(6).List()),
 			},
 			8: {
-				appendVector{V(""), V(""), V(""), V(""), V(""), V("")},
-				lenVector(6),
-				setVector{0: V("8"), 2: V("eight")},
-				truncVector(3),
-				equalVector(wantFS.Get(8).Vector()),
+				appendList{V(""), V(""), V(""), V(""), V(""), V("")},
+				lenList(6),
+				setList{0: V("8"), 2: V("eight")},
+				truncList(3),
+				equalList(wantFS.Get(8).List()),
 			},
 			10: {
-				appendVector{V([]byte(nil)), V([]byte(nil))},
-				setVector{0: V([]byte("10"))},
-				appendVector{V([]byte("wrong"))},
-				setVector{2: V([]byte("ten"))},
-				equalVector(wantFS.Get(10).Vector()),
+				appendList{V([]byte(nil)), V([]byte(nil))},
+				setList{0: V([]byte("10"))},
+				appendList{V([]byte("wrong"))},
+				setList{2: V([]byte("ten"))},
+				equalList(wantFS.Get(10).List()),
 			},
 			12: {
-				appendVector{V("12"), V("wrong"), V("twelve")},
-				setVector{1: V("")},
-				equalVector(wantFS.Get(12).Vector()),
+				appendList{V("12"), V("wrong"), V("twelve")},
+				setList{1: V("")},
+				equalList(wantFS.Get(12).List()),
 			},
 			14: {
-				appendVector{V([]byte("14")), V([]byte(nil)), V([]byte("fourteen"))},
-				equalVector(wantFS.Get(14).Vector()),
+				appendList{V([]byte("14")), V([]byte(nil)), V([]byte("fourteen"))},
+				equalList(wantFS.Get(14).List()),
 			},
 			16: {
-				appendVector{V("16"), V(""), V("sixteen"), V("extra")},
-				truncVector(3),
-				equalVector(wantFS.Get(16).Vector()),
+				appendList{V("16"), V(""), V("sixteen"), V("extra")},
+				truncList(3),
+				equalList(wantFS.Get(16).List()),
 			},
 			18: {
-				appendVector{V([]byte("18")), V([]byte(nil)), V([]byte("eighteen"))},
-				equalVector(wantFS.Get(18).Vector()),
+				appendList{V([]byte("18")), V([]byte(nil)), V([]byte("eighteen"))},
+				equalList(wantFS.Get(18).List()),
 			},
 		},
 		hasFields{1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, 10: true, 11: true, 12: true, 13: true, 14: true, 15: true, 16: true, 17: true, 18: true, 19: true},
@@ -828,7 +828,7 @@ var cmpOpts = cmp.Options{
 	cmp.Transformer("UnwrapValue", func(v pref.Value) interface{} {
 		return v.Interface()
 	}),
-	cmp.Transformer("UnwrapVector", func(v pref.Vector) interface{} {
+	cmp.Transformer("UnwrapList", func(v pref.List) interface{} {
 		return v.(interface{ Unwrap() interface{} }).Unwrap()
 	}),
 	cmp.Transformer("UnwrapMap", func(m pref.Map) interface{} {
@@ -874,10 +874,10 @@ func testMessage(t *testing.T, p path, m pref.Message, tt messageOps) {
 					fs.Clear(n)
 				}
 			}
-		case vectorFields:
+		case listFields:
 			for n, tt := range op {
 				p.Push(int(n))
-				testVectors(t, p, fs.Mutable(n).(pref.Vector), tt)
+				testLists(t, p, fs.Mutable(n).(pref.List), tt)
 				p.Pop()
 			}
 		case mapFields:
@@ -893,36 +893,36 @@ func testMessage(t *testing.T, p path, m pref.Message, tt messageOps) {
 	}
 }
 
-func testVectors(t *testing.T, p path, v pref.Vector, tt vectorOps) {
+func testLists(t *testing.T, p path, v pref.List, tt listOps) {
 	for i, op := range tt {
 		p.Push(i)
 		switch op := op.(type) {
-		case equalVector:
+		case equalList:
 			if diff := cmp.Diff(op, v, cmpOpts); diff != "" {
-				t.Errorf("operation %v, vector mismatch (-want, +got):\n%s", p, diff)
+				t.Errorf("operation %v, list mismatch (-want, +got):\n%s", p, diff)
 			}
-		case lenVector:
+		case lenList:
 			if got, want := v.Len(), int(op); got != want {
-				t.Errorf("operation %v, Vector.Len = %d, want %d", p, got, want)
+				t.Errorf("operation %v, List.Len = %d, want %d", p, got, want)
 			}
-		case getVector:
+		case getList:
 			got := map[int]pref.Value{}
 			want := map[int]pref.Value(op)
 			for n := range want {
 				got[n] = v.Get(n)
 			}
 			if diff := cmp.Diff(want, got, cmpOpts); diff != "" {
-				t.Errorf("operation %v, Vector.Get mismatch (-want, +got):\n%s", p, diff)
+				t.Errorf("operation %v, List.Get mismatch (-want, +got):\n%s", p, diff)
 			}
-		case setVector:
+		case setList:
 			for n, e := range op {
 				v.Set(n, e)
 			}
-		case appendVector:
+		case appendList:
 			for _, e := range op {
 				v.Append(e)
 			}
-		case truncVector:
+		case truncList:
 			v.Truncate(int(op))
 		default:
 			t.Fatalf("operation %v, invalid operation: %T", p, op)

internal/value/convert.go

@@ -14,7 +14,7 @@ import (
 )
 
 // Unwrapper unwraps the value to the underlying value.
-// This is implemented by Vector and Map.
+// This is implemented by List and Map.
 type Unwrapper interface {
 	Unwrap() interface{}
 }

internal/value/list.go

@@ -0,0 +1,63 @@
+// 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 value
+
+import (
+	"reflect"
+
+	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+)
+
+func ListOf(p interface{}, c Converter) pref.List {
+	// TODO: Validate that p is a *[]T?
+	rv := reflect.ValueOf(p).Elem()
+	return listReflect{rv, c}
+}
+
+type listReflect struct {
+	v    reflect.Value // addressable []T
+	conv Converter
+}
+
+func (ls listReflect) Len() int {
+	return ls.v.Len()
+}
+func (ls listReflect) Get(i int) pref.Value {
+	return ls.conv.PBValueOf(ls.v.Index(i))
+}
+func (ls listReflect) Set(i int, v pref.Value) {
+	ls.v.Index(i).Set(ls.conv.GoValueOf(v))
+}
+func (ls listReflect) Append(v pref.Value) {
+	ls.v.Set(reflect.Append(ls.v, ls.conv.GoValueOf(v)))
+}
+func (ls listReflect) Mutable(i int) pref.Mutable {
+	// Mutable is only valid for messages and panics for other kinds.
+	rv := ls.v.Index(i)
+	if rv.IsNil() {
+		// TODO: Is checking for nil proper behavior for custom messages?
+		pv := pref.ValueOf(ls.conv.MessageType.New().ProtoReflect())
+		rv.Set(ls.conv.GoValueOf(pv))
+	}
+	return rv.Interface().(pref.Message)
+}
+func (ls listReflect) MutableAppend() pref.Mutable {
+	// MutableAppend is only valid for messages and panics for other kinds.
+	pv := pref.ValueOf(ls.conv.MessageType.New().ProtoReflect())
+	ls.v.Set(reflect.Append(ls.v, ls.conv.GoValueOf(pv)))
+	return ls.v.Index(ls.Len() - 1).Interface().(pref.Message)
+}
+func (ls listReflect) Truncate(i int) {
+	ls.v.Set(ls.v.Slice(0, i))
+}
+func (ls listReflect) Unwrap() interface{} {
+	return ls.v.Addr().Interface()
+}
+func (ls listReflect) ProtoMutable() {}
+
+var (
+	_ pref.List = listReflect{}
+	_ Unwrapper = listReflect{}
+)

internal/value/vector.go

@@ -1,63 +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 value
-
-import (
-	"reflect"
-
-	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
-)
-
-func VectorOf(p interface{}, c Converter) pref.Vector {
-	// TODO: Validate that p is a *[]T?
-	rv := reflect.ValueOf(p).Elem()
-	return vectorReflect{rv, c}
-}
-
-type vectorReflect struct {
-	v    reflect.Value // addressable []T
-	conv Converter
-}
-
-func (vs vectorReflect) Len() int {
-	return vs.v.Len()
-}
-func (vs vectorReflect) Get(i int) pref.Value {
-	return vs.conv.PBValueOf(vs.v.Index(i))
-}
-func (vs vectorReflect) Set(i int, v pref.Value) {
-	vs.v.Index(i).Set(vs.conv.GoValueOf(v))
-}
-func (vs vectorReflect) Append(v pref.Value) {
-	vs.v.Set(reflect.Append(vs.v, vs.conv.GoValueOf(v)))
-}
-func (vs vectorReflect) Mutable(i int) pref.Mutable {
-	// Mutable is only valid for messages and panics for other kinds.
-	rv := vs.v.Index(i)
-	if rv.IsNil() {
-		// TODO: Is checking for nil proper behavior for custom messages?
-		pv := pref.ValueOf(vs.conv.MessageType.New().ProtoReflect())
-		rv.Set(vs.conv.GoValueOf(pv))
-	}
-	return rv.Interface().(pref.Message)
-}
-func (vs vectorReflect) MutableAppend() pref.Mutable {
-	// MutableAppend is only valid for messages and panics for other kinds.
-	pv := pref.ValueOf(vs.conv.MessageType.New().ProtoReflect())
-	vs.v.Set(reflect.Append(vs.v, vs.conv.GoValueOf(pv)))
-	return vs.v.Index(vs.Len() - 1).Interface().(pref.Message)
-}
-func (vs vectorReflect) Truncate(i int) {
-	vs.v.Set(vs.v.Slice(0, i))
-}
-func (vs vectorReflect) Unwrap() interface{} {
-	return vs.v.Addr().Interface()
-}
-func (vs vectorReflect) ProtoMutable() {}
-
-var (
-	_ pref.Vector = vectorReflect{}
-	_ Unwrapper   = vectorReflect{}
-)

reflect/protoreflect/type.go

@@ -305,7 +305,7 @@ type FieldDescriptor interface {
 	IsPacked() bool
 
 	// IsMap reports whether this field represents a map.
-	// The value type for the associated field is a Map instead of a Vector.
+	// The value type for the associated field is a Map instead of a List.
 	//
 	// If true, it implies that Kind is MessageKind, Cardinality is Repeated,
 	// and MessageDescriptor.IsMapEntry is true.
@@ -449,7 +449,7 @@ type ExtensionType interface {
 	// TODO: What to do with nil?
 	//	Should ValueOf(nil) return Value{}?
 	//	Should InterfaceOf(Value{}) return nil?
-	//	Similarly, should the Value.{Message,Vector,Map} also return nil?
+	//	Similarly, should the Value.{Message,List,Map} also return nil?
 
 	// ValueOf wraps the input and returns it as a Value.
 	// ValueOf panics if the input value is invalid or not the appropriate type.

reflect/protoreflect/value.go

@@ -42,8 +42,8 @@ type Message interface {
 
 // KnownFields provides accessor and mutator methods for known fields.
 //
-// Each field Value can either be a scalar, Message, Vector, or Map.
-// The field is a Vector or Map if FieldDescriptor.Cardinality is Repeated and
+// 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.
@@ -94,7 +94,7 @@ type KnownFields interface {
 
 	// Mutable returns a reference value for a field with a given field number,
 	// allocating a new instance if necessary.
-	// It panics if the field is not a map, vector, or message.
+	// It panics if the field is not a message, list, or map.
 	Mutable(FieldNumber) Mutable
 
 	// Range iterates over every populated field in an undefined order,
@@ -214,14 +214,14 @@ type ExtensionFieldTypes interface {
 	Range(f func(ExtensionType) bool)
 }
 
-// Vector is an ordered list. Every element is considered populated
+// List is an ordered list. Every element is considered populated
 // (i.e., Get never provides and Set never accepts invalid Values).
 // The element Value type is determined by the associated FieldDescriptor.Kind
-// and cannot be a Map or Vector.
+// and cannot be a Map or List.
 //
 // Len and Get are safe for concurrent use.
-type Vector interface {
-	// Len reports the number of entries in the Vector.
+type List interface {
+	// Len reports the number of entries in the List.
 	// Get, Set, Mutable, and Truncate panic with out of bound indexes.
 	Len() int
 
@@ -234,7 +234,7 @@ type Vector interface {
 	// value aliases the source's memory in any way.
 	Set(int, Value)
 
-	// Append appends the provided value to the end of the vector.
+	// Append appends the provided value to the end of the list.
 	//
 	// When appending a composite type, it is unspecified whether the appended
 	// value aliases the source's memory in any way.
@@ -251,7 +251,7 @@ type Vector interface {
 
 	// TODO: Should truncate accept two indexes similar to slicing?M
 
-	// Truncate truncates the vector to a smaller length.
+	// Truncate truncates the list to a smaller length.
 	Truncate(int)
 
 	// ProtoMutable is a marker method to implement the Mutable interface.
@@ -260,7 +260,7 @@ type Vector interface {
 
 // Map is an unordered, associative map. Only elements within the map
 // is considered populated. The entry Value type is determined by the associated
-// FieldDescripto.Kind and cannot be a Map or Vector.
+// FieldDescripto.Kind and cannot be a Map or List.
 //
 // Len, Has, Get, and Range are safe for concurrent use.
 type Map interface {
@@ -303,7 +303,7 @@ type Map interface {
 }
 
 // Mutable is a mutable reference, where mutate operations also affect
-// the backing store. Possible Mutable types: Vector, Map, or Message.
+// the backing store. Possible Mutable types: Message, List, or Map.
 type Mutable interface {
 	ProtoMutable()
 }

reflect/protoreflect/value_test.go

@@ -13,7 +13,7 @@ import (
 
 func TestValue(t *testing.T) {
 	fakeMessage := new(struct{ Message })
-	fakeVector := new(struct{ Vector })
+	fakeList := new(struct{ List })
 	fakeMap := new(struct{ Map })
 
 	tests := []struct {
@@ -32,7 +32,7 @@ func TestValue(t *testing.T) {
 		{in: ValueOf(string("hello")), want: string("hello")},
 		{in: ValueOf([]byte("hello")), want: []byte("hello")},
 		{in: ValueOf(fakeMessage), want: fakeMessage},
-		{in: ValueOf(fakeVector), want: fakeVector},
+		{in: ValueOf(fakeList), want: fakeList},
 		{in: ValueOf(fakeMap), want: fakeMap},
 	}
 
@@ -86,14 +86,14 @@ func TestValue(t *testing.T) {
 			if got := tt.in.Message(); got != want {
 				t.Errorf("Value(%v).Message() = %v, want %v", tt.in, got, tt.want)
 			}
+		case List:
+			if got := tt.in.List(); got != want {
+				t.Errorf("Value(%v).List() = %v, want %v", tt.in, got, tt.want)
+			}
 		case Map:
 			if got := tt.in.Map(); got != want {
 				t.Errorf("Value(%v).Map() = %v, want %v", tt.in, got, tt.want)
 			}
-		case Vector:
-			if got := tt.in.Vector(); got != want {
-				t.Errorf("Value(%v).Vector() = %v, want %v", tt.in, got, tt.want)
-			}
 		}
 	}
 }

reflect/protoreflect/value_union.go

@@ -29,7 +29,7 @@ import (
 //	| EnumNumber | EnumKind                            |
 //	+------------+-------------------------------------+
 //	| Message    | MessageKind, GroupKind              |
-//	| Vector     |                                     |
+//	| List       |                                     |
 //	| Map        |                                     |
 //	+------------+-------------------------------------+
 //
@@ -38,7 +38,7 @@ import (
 // Int64Kind, Sint64Kind, and Sfixed64Kind are all represented by int64,
 // but use different integer encoding methods.
 //
-// The Vector or Map types are used if the FieldDescriptor.Cardinality of the
+// The List or Map types are used if the FieldDescriptor.Cardinality of the
 // corresponding field is Repeated and a Map if and only if
 // FieldDescriptor.IsMap is true.
 //
@@ -93,7 +93,7 @@ func ValueOf(v interface{}) Value {
 		return valueOfBytes(v[:len(v):len(v)])
 	case EnumNumber:
 		return Value{typ: enumType, num: uint64(v)}
-	case Message, Vector, Map:
+	case Message, List, Map:
 		return valueOfIface(v)
 	default:
 		// TODO: Special case ProtoEnum, ProtoMessage, *[]T, and *map[K]V?
@@ -222,10 +222,10 @@ func (v Value) Message() Message {
 	}
 }
 
-// Vector returns v as a Vector and panics if the type is not a Vector.
-func (v Value) Vector() Vector {
+// List returns v as a List and panics if the type is not a List.
+func (v Value) List() List {
 	switch v := v.getIface().(type) {
-	case Vector:
+	case List:
 		return v
 	default:
 		panic("proto: value type mismatch")

reflect/prototype/go_type.go

@@ -86,7 +86,7 @@ func (t *goMessage) New() protoreflect.ProtoMessage {
 // in which case it replaces the original message in ExtensionDescriptor.
 //
 // The Go type is currently determined automatically.
-// The type is T for scalars and *[]T for vectors (maps are not allowed).
+// The type is T for scalars and *[]T for lists (maps are not allowed).
 // The type T is determined as follows:
 //
 //	+------------+-------------------------------------+
@@ -244,13 +244,13 @@ func (t *goExtension) lazyInit() {
 				return reflect.New(t.typ.Elem()).Interface()
 			}
 			t.valueOf = func(v interface{}) protoreflect.Value {
-				return protoreflect.ValueOf(value.VectorOf(v, c))
+				return protoreflect.ValueOf(value.ListOf(v, c))
 			}
 			t.interfaceOf = func(pv protoreflect.Value) interface{} {
-				// TODO: Can we assume that Vector implementations know how
+				// TODO: Can we assume that List implementations know how
 				// to unwrap themselves?
 				// Should this be part of the public API in protoreflect?
-				return pv.Vector().(value.Unwrapper).Unwrap()
+				return pv.List().(value.Unwrapper).Unwrap()
 			}
 		default:
 			panic(fmt.Sprintf("invalid cardinality: %v", t.Cardinality()))