GODRIVER-2453 Run make fmt with the latest Go version.

bson/bson.go

@@ -27,7 +27,7 @@ type Zeroer interface {
 //
 // Example usage:
 //
-// 		bson.D{{"foo", "bar"}, {"hello", "world"}, {"pi", 3.14159}}
+//	bson.D{{"foo", "bar"}, {"hello", "world"}, {"pi", 3.14159}}
 type D = primitive.D
 
 // E represents a BSON element for a D. It is usually used inside a D.
@@ -39,12 +39,12 @@ type E = primitive.E
 //
 // Example usage:
 //
-// 		bson.M{"foo": "bar", "hello": "world", "pi": 3.14159}
+//	bson.M{"foo": "bar", "hello": "world", "pi": 3.14159}
 type M = primitive.M
 
 // An A is an ordered representation of a BSON array.
 //
 // Example usage:
 //
-// 		bson.A{"bar", "world", 3.14159, bson.D{{"qux", 12345}}}
+//	bson.A{"bar", "world", 3.14159, bson.D{{"qux", 12345}}}
 type A = primitive.A

bson/bsoncodec/doc.go

@@ -17,7 +17,7 @@
 // 2) A Registry that holds these ValueEncoders and ValueDecoders and provides methods for
 // retrieving them.
 //
-// ValueEncoders and ValueDecoders
+// # ValueEncoders and ValueDecoders
 //
 // The ValueEncoder interface is implemented by types that can encode a provided Go type to BSON.
 // The value to encode is provided as a reflect.Value and a bsonrw.ValueWriter is used within the
@@ -31,7 +31,7 @@
 // allow the use of a function with the correct signature as a ValueDecoder. A DecodeContext
 // instance is provided and serves similar functionality to the EncodeContext.
 //
-// Registry and RegistryBuilder
+// # Registry and RegistryBuilder
 //
 // A Registry is an immutable store for ValueEncoders, ValueDecoders, and a type map. See the Registry type
 // documentation for examples of registering various custom encoders and decoders. A Registry can be constructed using a
@@ -53,15 +53,15 @@
 // values decode as Go int32 and int64 instances, respectively, when decoding into a bson.D. The following code would
 // change the behavior so these values decode as Go int instances instead:
 //
-//		intType := reflect.TypeOf(int(0))
-//		registryBuilder.RegisterTypeMapEntry(bsontype.Int32, intType).RegisterTypeMapEntry(bsontype.Int64, intType)
+//	intType := reflect.TypeOf(int(0))
+//	registryBuilder.RegisterTypeMapEntry(bsontype.Int32, intType).RegisterTypeMapEntry(bsontype.Int64, intType)
 //
 // 4. Kind encoder/decoders - These can be registered using the RegisterDefaultEncoder and RegisterDefaultDecoder
 // methods. The registered codec will be invoked when encoding or decoding values whose reflect.Kind matches the
 // registered reflect.Kind as long as the value's type doesn't match a registered type or hook encoder/decoder first.
 // These methods should be used to change the behavior for all values for a specific kind.
 //
-// Registry Lookup Procedure
+// # Registry Lookup Procedure
 //
 // When looking up an encoder in a Registry, the precedence rules are as follows:
 //
@@ -79,7 +79,7 @@
 // rules apply for decoders, with the exception that an error of type ErrNoDecoder will be returned if no decoder is
 // found.
 //
-// DefaultValueEncoders and DefaultValueDecoders
+// # DefaultValueEncoders and DefaultValueDecoders
 //
 // The DefaultValueEncoders and DefaultValueDecoders types provide a full set of ValueEncoders and
 // ValueDecoders for handling a wide range of Go types, including all of the types within the

bson/bsoncodec/registry.go

@@ -254,6 +254,7 @@ func (rb *RegistryBuilder) RegisterDefaultDecoder(kind reflect.Kind, dec ValueDe
 // By default, BSON documents will decode into interface{} values as bson.D. To change the default type for BSON
 // documents, a type map entry for bsontype.EmbeddedDocument should be registered. For example, to force BSON documents
 // to decode to bson.Raw, use the following code:
+//
 //	rb.RegisterTypeMapEntry(bsontype.EmbeddedDocument, reflect.TypeOf(bson.Raw{}))
 func (rb *RegistryBuilder) RegisterTypeMapEntry(bt bsontype.Type, rt reflect.Type) *RegistryBuilder {
 	rb.typeMap[bt] = rt

bson/bsoncodec/struct_tag_parser.go

@@ -34,21 +34,21 @@ func (stpf StructTagParserFunc) ParseStructTags(sf reflect.StructField) (StructT
 //
 // The properties are defined below:
 //
-//     OmitEmpty  Only include the field if it's not set to the zero value for the type or to
-//                empty slices or maps.
+//	OmitEmpty  Only include the field if it's not set to the zero value for the type or to
+//	           empty slices or maps.
 //
-//     MinSize    Marshal an integer of a type larger than 32 bits value as an int32, if that's
-//                feasible while preserving the numeric value.
+//	MinSize    Marshal an integer of a type larger than 32 bits value as an int32, if that's
+//	           feasible while preserving the numeric value.
 //
-//     Truncate   When unmarshaling a BSON double, it is permitted to lose precision to fit within
-//                a float32.
+//	Truncate   When unmarshaling a BSON double, it is permitted to lose precision to fit within
+//	           a float32.
 //
-//     Inline     Inline the field, which must be a struct or a map, causing all of its fields
-//                or keys to be processed as if they were part of the outer struct. For maps,
-//                keys must not conflict with the bson keys of other struct fields.
+//	Inline     Inline the field, which must be a struct or a map, causing all of its fields
+//	           or keys to be processed as if they were part of the outer struct. For maps,
+//	           keys must not conflict with the bson keys of other struct fields.
 //
-//     Skip       This struct field should be skipped. This is usually denoted by parsing a "-"
-//                for the name.
+//	Skip       This struct field should be skipped. This is usually denoted by parsing a "-"
+//	           for the name.
 //
 // TODO(skriptble): Add tags for undefined as nil and for null as nil.
 type StructTags struct {
@@ -67,20 +67,20 @@ type StructTags struct {
 // If there is no name in the struct tag fields, the struct field name is lowercased.
 // The tag formats accepted are:
 //
-//     "[<key>][,<flag1>[,<flag2>]]"
+//	"[<key>][,<flag1>[,<flag2>]]"
 //
-//     `(...) bson:"[<key>][,<flag1>[,<flag2>]]" (...)`
+//	`(...) bson:"[<key>][,<flag1>[,<flag2>]]" (...)`
 //
 // An example:
 //
-//     type T struct {
-//         A bool
-//         B int    "myb"
-//         C string "myc,omitempty"
-//         D string `bson:",omitempty" json:"jsonkey"`
-//         E int64  ",minsize"
-//         F int64  "myf,omitempty,minsize"
-//     }
+//	type T struct {
+//	    A bool
+//	    B int    "myb"
+//	    C string "myc,omitempty"
+//	    D string `bson:",omitempty" json:"jsonkey"`
+//	    E int64  ",minsize"
+//	    F int64  "myf,omitempty,minsize"
+//	}
 //
 // A struct tag either consisting entirely of '-' or with a bson key with a
 // value consisting entirely of '-' will return a StructTags with Skip true and

bson/doc.go

@@ -9,21 +9,22 @@
 // The BSON library handles marshalling and unmarshalling of values through a configurable codec system. For a description
 // of the codec system and examples of registering custom codecs, see the bsoncodec package.
 //
-// Raw BSON
+// # Raw BSON
 //
 // The Raw family of types is used to validate and retrieve elements from a slice of bytes. This
 // type is most useful when you want do lookups on BSON bytes without unmarshaling it into another
 // type.
 //
 // Example:
-// 		var raw bson.Raw = ... // bytes from somewhere
-// 		err := raw.Validate()
-// 		if err != nil { return err }
-// 		val := raw.Lookup("foo")
-// 		i32, ok := val.Int32OK()
-// 		// do something with i32...
 //
-// Native Go Types
+//	var raw bson.Raw = ... // bytes from somewhere
+//	err := raw.Validate()
+//	if err != nil { return err }
+//	val := raw.Lookup("foo")
+//	i32, ok := val.Int32OK()
+//	// do something with i32...
+//
+// # Native Go Types
 //
 // The D and M types defined in this package can be used to build representations of BSON using native Go types. D is a
 // slice and M is a map. For more information about the use cases for these types, see the documentation on the type
@@ -32,63 +33,64 @@
 // Note that a D should not be constructed with duplicate key names, as that can cause undefined server behavior.
 //
 // Example:
-// 		bson.D{{"foo", "bar"}, {"hello", "world"}, {"pi", 3.14159}}
-//		bson.M{"foo": "bar", "hello": "world", "pi": 3.14159}
+//
+//	bson.D{{"foo", "bar"}, {"hello", "world"}, {"pi", 3.14159}}
+//	bson.M{"foo": "bar", "hello": "world", "pi": 3.14159}
 //
 // When decoding BSON to a D or M, the following type mappings apply when unmarshalling:
 //
-// 		1. BSON int32 unmarshals to an int32.
-// 		2. BSON int64 unmarshals to an int64.
-// 		3. BSON double unmarshals to a float64.
-// 		4. BSON string unmarshals to a string.
-// 		5. BSON boolean unmarshals to a bool.
-// 		6. BSON embedded document unmarshals to the parent type (i.e. D for a D, M for an M).
-// 		7. BSON array unmarshals to a bson.A.
-// 		8. BSON ObjectId unmarshals to a primitive.ObjectID.
-// 		9. BSON datetime unmarshals to a primitive.DateTime.
-// 		10. BSON binary unmarshals to a primitive.Binary.
-// 		11. BSON regular expression unmarshals to a primitive.Regex.
-// 		12. BSON JavaScript unmarshals to a primitive.JavaScript.
-// 		13. BSON code with scope unmarshals to a primitive.CodeWithScope.
-// 		14. BSON timestamp unmarshals to an primitive.Timestamp.
-// 		15. BSON 128-bit decimal unmarshals to an primitive.Decimal128.
-// 		16. BSON min key unmarshals to an primitive.MinKey.
-// 		17. BSON max key unmarshals to an primitive.MaxKey.
-// 		18. BSON undefined unmarshals to a primitive.Undefined.
-// 		19. BSON null unmarshals to nil.
-// 		20. BSON DBPointer unmarshals to a primitive.DBPointer.
-// 		21. BSON symbol unmarshals to a primitive.Symbol.
+//  1. BSON int32 unmarshals to an int32.
+//  2. BSON int64 unmarshals to an int64.
+//  3. BSON double unmarshals to a float64.
+//  4. BSON string unmarshals to a string.
+//  5. BSON boolean unmarshals to a bool.
+//  6. BSON embedded document unmarshals to the parent type (i.e. D for a D, M for an M).
+//  7. BSON array unmarshals to a bson.A.
+//  8. BSON ObjectId unmarshals to a primitive.ObjectID.
+//  9. BSON datetime unmarshals to a primitive.DateTime.
+//  10. BSON binary unmarshals to a primitive.Binary.
+//  11. BSON regular expression unmarshals to a primitive.Regex.
+//  12. BSON JavaScript unmarshals to a primitive.JavaScript.
+//  13. BSON code with scope unmarshals to a primitive.CodeWithScope.
+//  14. BSON timestamp unmarshals to an primitive.Timestamp.
+//  15. BSON 128-bit decimal unmarshals to an primitive.Decimal128.
+//  16. BSON min key unmarshals to an primitive.MinKey.
+//  17. BSON max key unmarshals to an primitive.MaxKey.
+//  18. BSON undefined unmarshals to a primitive.Undefined.
+//  19. BSON null unmarshals to nil.
+//  20. BSON DBPointer unmarshals to a primitive.DBPointer.
+//  21. BSON symbol unmarshals to a primitive.Symbol.
 //
 // The above mappings also apply when marshalling a D or M to BSON. Some other useful marshalling mappings are:
 //
-//       1. time.Time marshals to a BSON datetime.
-//       2. int8, int16, and int32 marshal to a BSON int32.
-//       3. int marshals to a BSON int32 if the value is between math.MinInt32 and math.MaxInt32, inclusive, and a BSON int64
-//       otherwise.
-//       4. int64 marshals to BSON int64.
-//       5. uint8 and uint16 marshal to a BSON int32.
-//       6. uint, uint32, and uint64 marshal to a BSON int32 if the value is between math.MinInt32 and math.MaxInt32,
-//       inclusive, and BSON int64 otherwise.
-//       7. BSON null and undefined values will unmarshal into the zero value of a field (e.g. unmarshalling a BSON null or
-//       undefined value into a string will yield the empty string.).
+//  1. time.Time marshals to a BSON datetime.
+//  2. int8, int16, and int32 marshal to a BSON int32.
+//  3. int marshals to a BSON int32 if the value is between math.MinInt32 and math.MaxInt32, inclusive, and a BSON int64
+//     otherwise.
+//  4. int64 marshals to BSON int64.
+//  5. uint8 and uint16 marshal to a BSON int32.
+//  6. uint, uint32, and uint64 marshal to a BSON int32 if the value is between math.MinInt32 and math.MaxInt32,
+//     inclusive, and BSON int64 otherwise.
+//  7. BSON null and undefined values will unmarshal into the zero value of a field (e.g. unmarshalling a BSON null or
+//     undefined value into a string will yield the empty string.).
 //
-// Structs
+// # Structs
 //
 // Structs can be marshalled/unmarshalled to/from BSON or Extended JSON. When transforming structs to/from BSON or Extended
 // JSON, the following rules apply:
 //
-//     1. Only exported fields in structs will be marshalled or unmarshalled.
+//  1. Only exported fields in structs will be marshalled or unmarshalled.
 //
-//     2. When marshalling a struct, each field will be lowercased to generate the key for the corresponding BSON element.
+//  2. When marshalling a struct, each field will be lowercased to generate the key for the corresponding BSON element.
 //     For example, a struct field named "Foo" will generate key "foo". This can be overridden via a struct tag (e.g.
 //     `bson:"fooField"` to generate key "fooField" instead).
 //
-//     3. An embedded struct field is marshalled as a subdocument. The key will be the lowercased name of the field's type.
+//  3. An embedded struct field is marshalled as a subdocument. The key will be the lowercased name of the field's type.
 //
-//     4. A pointer field is marshalled as the underlying type if the pointer is non-nil. If the pointer is nil, it is
+//  4. A pointer field is marshalled as the underlying type if the pointer is non-nil. If the pointer is nil, it is
 //     marshalled as a BSON null value.
 //
-//     5. When unmarshalling, a field of type interface{} will follow the D/M type mappings listed above. BSON documents
+//  5. When unmarshalling, a field of type interface{} will follow the D/M type mappings listed above. BSON documents
 //     unmarshalled into an interface{} field will be unmarshalled as a D.
 //
 // The encoding of each struct field can be customized by the "bson" struct tag.
@@ -98,13 +100,14 @@
 // are not honored, but that can be enabled by creating a StructCodec with JSONFallbackStructTagParser, like below:
 //
 // Example:
-//      structcodec, _ := bsoncodec.NewStructCodec(bsoncodec.JSONFallbackStructTagParser)
+//
+//	structcodec, _ := bsoncodec.NewStructCodec(bsoncodec.JSONFallbackStructTagParser)
 //
 // The bson tag gives the name of the field, possibly followed by a comma-separated list of options.
 // The name may be empty in order to specify options without overriding the default field name. The following options can be used
 // to configure behavior:
 //
-//     1. omitempty: If the omitempty struct tag is specified on a field, the field will not be marshalled if it is set to
+//  1. omitempty: If the omitempty struct tag is specified on a field, the field will not be marshalled if it is set to
 //     the zero value. Fields with language primitive types such as integers, booleans, and strings are considered empty if
 //     their value is equal to the zero value for the type (i.e. 0 for integers, false for booleans, and "" for strings).
 //     Slices, maps, and arrays are considered empty if they are of length zero. Interfaces and pointers are considered
@@ -113,16 +116,16 @@
 //     never considered empty and will be marshalled as embedded documents.
 //     NOTE: It is recommended that this tag be used for all slice and map fields.
 //
-//     2. minsize: If the minsize struct tag is specified on a field of type int64, uint, uint32, or uint64 and the value of
+//  2. minsize: If the minsize struct tag is specified on a field of type int64, uint, uint32, or uint64 and the value of
 //     the field can fit in a signed int32, the field will be serialized as a BSON int32 rather than a BSON int64. For other
 //     types, this tag is ignored.
 //
-//     3. truncate: If the truncate struct tag is specified on a field with a non-float numeric type, BSON doubles unmarshalled
+//  3. truncate: If the truncate struct tag is specified on a field with a non-float numeric type, BSON doubles unmarshalled
 //     into that field will be truncated at the decimal point. For example, if 3.14 is unmarshalled into a field of type int,
 //     it will be unmarshalled as 3. If this tag is not specified, the decoder will throw an error if the value cannot be
 //     decoded without losing precision. For float64 or non-numeric types, this tag is ignored.
 //
-//     4. inline: If the inline struct tag is specified for a struct or map field, the field will be "flattened" when
+//  4. inline: If the inline struct tag is specified for a struct or map field, the field will be "flattened" when
 //     marshalling and "un-flattened" when unmarshalling. This means that all of the fields in that struct/map will be
 //     pulled up one level and will become top-level fields rather than being fields in a nested document. For example, if a
 //     map field named "Map" with value map[string]interface{}{"foo": "bar"} is inlined, the resulting document will be
@@ -132,7 +135,7 @@
 //     This tag can be used with fields that are pointers to structs. If an inlined pointer field is nil, it will not be
 //     marshalled. For fields that are not maps or structs, this tag is ignored.
 //
-// Marshalling and Unmarshalling
+// # Marshalling and Unmarshalling
 //
 // Manually marshalling and unmarshalling can be done with the Marshal and Unmarshal family of functions.
 package bson