filetype.Builder.Build - Code Metrics - Inspection of "Adding vendor folder" - cdleo/go-sqldb - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — main ( 973aa1...436074 )

by Christian

created 2022-06-16 19:46 UTC

filetype.Builder.Build F

↳ Parent: vendor/google.golang.org/protobuf/internal/filetype/build.go

Complexity

Conditions

Size

Total Lines	121
Code Lines	76

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	31
eloc	76
nop	0
dl	0
loc	121
rs	0
c	0
b	0
f	0

How to fix Long Method Complexity

// 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 filetype provides functionality for wrapping descriptors
// with Go type information.
package filetype

import (
	"reflect"

	"google.golang.org/protobuf/internal/descopts"
	fdesc "google.golang.org/protobuf/internal/filedesc"
	pimpl "google.golang.org/protobuf/internal/impl"
	pref "google.golang.org/protobuf/reflect/protoreflect"
	preg "google.golang.org/protobuf/reflect/protoregistry"
)

// Builder constructs type descriptors from a raw file descriptor
// and associated Go types for each enum and message declaration.
//
//
// Flattened Ordering
//
// 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
// resolve a dependency, which is information that must be provided separately
// since it cannot be derived from the file descriptor alone.
//
// However, representing a tree as Go literals is difficult to simply do in a
// space and time efficient way. Thus, we store them as a flattened list of
// objects where the serialization order from the tree-based form is important.
//
// The "flattened ordering" is defined as a tree traversal of all enum, message,
// extension, and service declarations using the following algorithm:
//
//	def VisitFileDecls(fd):
//		for e in fd.Enums:      yield e
//		for m in fd.Messages:   yield m
//		for x in fd.Extensions: yield x
//		for s in fd.Services:   yield s
//		for m in fd.Messages:   yield from VisitMessageDecls(m)
//
//	def VisitMessageDecls(md):
//		for e in md.Enums:      yield e
//		for m in md.Messages:   yield m
//		for x in md.Extensions: yield x
//		for m in md.Messages:   yield from VisitMessageDecls(m)
//
// The traversal starts at the root file descriptor and yields each direct
// declaration within each node before traversing into sub-declarations
// that children themselves may have.
type Builder struct {
	// File is the underlying file descriptor builder.
	File fdesc.Builder

	// 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.
	//
	// Declarations are Go types generated for enums and messages directly
	// declared (not publicly imported) in the proto source file.
	// Messages for map entries are accounted for, but represented by nil.
	// Enum declarations in "flattened ordering" come first, followed by
	// message declarations in "flattened ordering".
	//
	// Dependencies are Go types for enums or messages referenced by
	// message fields (excluding weak fields), for parent extended messages of
	// extension fields, for enums or messages referenced by extension fields,
	// and for input and output messages referenced by service methods.
	// Dependencies must come after declarations, but the ordering of
	// dependencies themselves is unspecified.
	GoTypes []interface{}

	// DependencyIndexes is an ordered list of indexes into GoTypes for the
	// dependencies of messages, extensions, or services.
	//
	// There are 5 sub-lists in "flattened ordering" concatenated back-to-back:
	//	0. Message field dependencies: list of the enum or message type
	//	referred to by every message field.
	//	1. Extension field targets: list of the extended parent message of
	//	every extension.
	//	2. Extension field dependencies: list of the enum or message type
	//	referred to by every extension field.
	//	3. Service method inputs: list of the input message type
	//	referred to by every service method.
	//	4. Service method outputs: list of the output message type
	//	referred to by every service method.
	//
	// The offset into DependencyIndexes for the start of each sub-list
	// is appended to the end in reverse order.
	DependencyIndexes []int32

	// EnumInfos is a list of enum infos in "flattened ordering".
	EnumInfos []pimpl.EnumInfo

	// MessageInfos is a list of message infos in "flattened ordering".
	// If provided, the GoType and PBType for each element is populated.
	//
	// Requirement: len(MessageInfos) == len(Build.Messages)
	MessageInfos []pimpl.MessageInfo

	// ExtensionInfos is a list of extension infos in "flattened ordering".
	// Each element is initialized and registered with the protoregistry package.
	//
	// Requirement: len(LegacyExtensions) == len(Build.Extensions)
	ExtensionInfos []pimpl.ExtensionInfo

	// TypeRegistry is the registry to register each type descriptor.
	// If nil, it uses protoregistry.GlobalTypes.
	TypeRegistry interface {
		RegisterMessage(pref.MessageType) error
		RegisterEnum(pref.EnumType) error
		RegisterExtension(pref.ExtensionType) error
	}
}

// Out is the output of the builder.
type Out struct {
	File pref.FileDescriptor
}

func (tb Builder) Build() (out Out) {
	// Replace the resolver with one that resolves dependencies by index,
	// which is faster and more reliable than relying on the global registry.
	if tb.File.FileRegistry == nil {
		tb.File.FileRegistry = preg.GlobalFiles
	}
	tb.File.FileRegistry = &resolverByIndex{
		goTypes:      tb.GoTypes,
		depIdxs:      tb.DependencyIndexes,
		fileRegistry: tb.File.FileRegistry,
	}

	// Initialize registry if unpopulated.
	if tb.TypeRegistry == nil {
		tb.TypeRegistry = preg.GlobalTypes
	}

	fbOut := tb.File.Build()
	out.File = fbOut.File

	// Process enums.
	enumGoTypes := tb.GoTypes[:len(fbOut.Enums)]
	if len(tb.EnumInfos) != len(fbOut.Enums) {
		panic("mismatching enum lengths")
	}
	if len(fbOut.Enums) > 0 {
		for i := range fbOut.Enums {
			tb.EnumInfos[i] = pimpl.EnumInfo{
				GoReflectType: reflect.TypeOf(enumGoTypes[i]),
				Desc:          &fbOut.Enums[i],
			}
			// Register enum types.
			if err := tb.TypeRegistry.RegisterEnum(&tb.EnumInfos[i]); err != nil {
				panic(err)
			}
		}
	}

	// Process messages.
	messageGoTypes := tb.GoTypes[len(fbOut.Enums):][:len(fbOut.Messages)]
	if len(tb.MessageInfos) != len(fbOut.Messages) {
		panic("mismatching message lengths")
	}
	if len(fbOut.Messages) > 0 {
		for i := range fbOut.Messages {
			if messageGoTypes[i] == nil {
				continue // skip map entry
			}

			tb.MessageInfos[i].GoReflectType = reflect.TypeOf(messageGoTypes[i])
			tb.MessageInfos[i].Desc = &fbOut.Messages[i]

			// Register message types.
			if err := tb.TypeRegistry.RegisterMessage(&tb.MessageInfos[i]); err != nil {
				panic(err)
			}
		}

		// As a special-case for descriptor.proto,
		// locally register concrete message type for the options.
		if out.File.Path() == "google/protobuf/descriptor.proto" && out.File.Package() == "google.protobuf" {
			for i := range fbOut.Messages {
				switch fbOut.Messages[i].Name() {
				case "FileOptions":
					descopts.File = messageGoTypes[i].(pref.ProtoMessage)
				case "EnumOptions":
					descopts.Enum = messageGoTypes[i].(pref.ProtoMessage)
				case "EnumValueOptions":
					descopts.EnumValue = messageGoTypes[i].(pref.ProtoMessage)
				case "MessageOptions":
					descopts.Message = messageGoTypes[i].(pref.ProtoMessage)
				case "FieldOptions":
					descopts.Field = messageGoTypes[i].(pref.ProtoMessage)
				case "OneofOptions":
					descopts.Oneof = messageGoTypes[i].(pref.ProtoMessage)
				case "ExtensionRangeOptions":
					descopts.ExtensionRange = messageGoTypes[i].(pref.ProtoMessage)
				case "ServiceOptions":
					descopts.Service = messageGoTypes[i].(pref.ProtoMessage)
				case "MethodOptions":
					descopts.Method = messageGoTypes[i].(pref.ProtoMessage)
				}
			}
		}
	}

	// Process extensions.
	if len(tb.ExtensionInfos) != len(fbOut.Extensions) {
		panic("mismatching extension lengths")
	}
	var depIdx int32
	for i := range fbOut.Extensions {
		// For enum and message kinds, determine the referent Go type so
		// that we can construct their constructors.
		const listExtDeps = 2
		var goType reflect.Type
		switch fbOut.Extensions[i].L1.Kind {
		case pref.EnumKind:
			j := depIdxs.Get(tb.DependencyIndexes, listExtDeps, depIdx)
			goType = reflect.TypeOf(tb.GoTypes[j])
			depIdx++
		case pref.MessageKind, pref.GroupKind:
			j := depIdxs.Get(tb.DependencyIndexes, listExtDeps, depIdx)
			goType = reflect.TypeOf(tb.GoTypes[j])
			depIdx++
		default:
			goType = goTypeForPBKind[fbOut.Extensions[i].L1.Kind]
		}
		if fbOut.Extensions[i].IsList() {
			goType = reflect.SliceOf(goType)
		}

		pimpl.InitExtensionInfo(&tb.ExtensionInfos[i], &fbOut.Extensions[i], goType)

		// Register extension types.
		if err := tb.TypeRegistry.RegisterExtension(&tb.ExtensionInfos[i]); err != nil {
			panic(err)
		}
	}

	return out
}

var goTypeForPBKind = map[pref.Kind]reflect.Type{
	pref.BoolKind:     reflect.TypeOf(bool(false)),
	pref.Int32Kind:    reflect.TypeOf(int32(0)),
	pref.Sint32Kind:   reflect.TypeOf(int32(0)),
	pref.Sfixed32Kind: reflect.TypeOf(int32(0)),
	pref.Int64Kind:    reflect.TypeOf(int64(0)),
	pref.Sint64Kind:   reflect.TypeOf(int64(0)),
	pref.Sfixed64Kind: reflect.TypeOf(int64(0)),
	pref.Uint32Kind:   reflect.TypeOf(uint32(0)),
	pref.Fixed32Kind:  reflect.TypeOf(uint32(0)),
	pref.Uint64Kind:   reflect.TypeOf(uint64(0)),
	pref.Fixed64Kind:  reflect.TypeOf(uint64(0)),
	pref.FloatKind:    reflect.TypeOf(float32(0)),
	pref.DoubleKind:   reflect.TypeOf(float64(0)),
	pref.StringKind:   reflect.TypeOf(string("")),
	pref.BytesKind:    reflect.TypeOf([]byte(nil)),
}

type depIdxs []int32

// Get retrieves the jth element of the ith sub-list.
func (x depIdxs) Get(i, j int32) int32 {
	return x[x[int32(len(x))-i-1]+j]
}

type (
	resolverByIndex struct {
		goTypes []interface{}
		depIdxs depIdxs
		fileRegistry
	}
	fileRegistry interface {
		FindFileByPath(string) (pref.FileDescriptor, error)
		FindDescriptorByName(pref.FullName) (pref.Descriptor, error)
		RegisterFile(pref.FileDescriptor) error
	}
)

func (r *resolverByIndex) FindEnumByIndex(i, j int32, es []fdesc.Enum, ms []fdesc.Message) pref.EnumDescriptor {
	if depIdx := int(r.depIdxs.Get(i, j)); int(depIdx) < len(es)+len(ms) {
		return &es[depIdx]
	} else {
		return pimpl.Export{}.EnumDescriptorOf(r.goTypes[depIdx])
	}
}

func (r *resolverByIndex) FindMessageByIndex(i, j int32, es []fdesc.Enum, ms []fdesc.Message) pref.MessageDescriptor {
	if depIdx := int(r.depIdxs.Get(i, j)); depIdx < len(es)+len(ms) {
		return &ms[depIdx-len(es)]
	} else {
		return pimpl.Export{}.MessageDescriptorOf(r.goTypes[depIdx])
	}
}


1			// Copyright 2019 The Go Authors. All rights reserved.
2			// Use of this source code is governed by a BSD-style
3			// license that can be found in the LICENSE file.
4
5			// Package filetype provides functionality for wrapping descriptors
6			// with Go type information.
7			package filetype
8
9			import (
10			"reflect"
11
12			"google.golang.org/protobuf/internal/descopts"
13			fdesc "google.golang.org/protobuf/internal/filedesc"
14			pimpl "google.golang.org/protobuf/internal/impl"
15			pref "google.golang.org/protobuf/reflect/protoreflect"
16			preg "google.golang.org/protobuf/reflect/protoregistry"
17			)
18
19			// Builder constructs type descriptors from a raw file descriptor
20			// and associated Go types for each enum and message declaration.
21			//
22			//
23			// Flattened Ordering
24			//
25			// The protobuf type system represents declarations as a tree. Certain nodes in
26			// the tree require us to either associate it with a concrete Go type or to
27			// resolve a dependency, which is information that must be provided separately
28			// since it cannot be derived from the file descriptor alone.
29			//
30			// However, representing a tree as Go literals is difficult to simply do in a
31			// space and time efficient way. Thus, we store them as a flattened list of
32			// objects where the serialization order from the tree-based form is important.
33			//
34			// The "flattened ordering" is defined as a tree traversal of all enum, message,
35			// extension, and service declarations using the following algorithm:
36			//
37			// def VisitFileDecls(fd):
38			// for e in fd.Enums: yield e
39			// for m in fd.Messages: yield m
40			// for x in fd.Extensions: yield x
41			// for s in fd.Services: yield s
42			// for m in fd.Messages: yield from VisitMessageDecls(m)
43			//
44			// def VisitMessageDecls(md):
45			// for e in md.Enums: yield e
46			// for m in md.Messages: yield m
47			// for x in md.Extensions: yield x
48			// for m in md.Messages: yield from VisitMessageDecls(m)
49			//
50			// The traversal starts at the root file descriptor and yields each direct
51			// declaration within each node before traversing into sub-declarations
52			// that children themselves may have.
53			type Builder struct {
54			// File is the underlying file descriptor builder.
55			File fdesc.Builder
56
57			// GoTypes is a unique set of the Go types for all declarations and
58			// dependencies. Each type is represented as a zero value of the Go type.
59			//
60			// Declarations are Go types generated for enums and messages directly
61			// declared (not publicly imported) in the proto source file.
62			// Messages for map entries are accounted for, but represented by nil.
63			// Enum declarations in "flattened ordering" come first, followed by
64			// message declarations in "flattened ordering".
65			//
66			// Dependencies are Go types for enums or messages referenced by
67			// message fields (excluding weak fields), for parent extended messages of
68			// extension fields, for enums or messages referenced by extension fields,
69			// and for input and output messages referenced by service methods.
70			// Dependencies must come after declarations, but the ordering of
71			// dependencies themselves is unspecified.
72			GoTypes []interface{}
73
74			// DependencyIndexes is an ordered list of indexes into GoTypes for the
75			// dependencies of messages, extensions, or services.
76			//
77			// There are 5 sub-lists in "flattened ordering" concatenated back-to-back:
78			// 0. Message field dependencies: list of the enum or message type
79			// referred to by every message field.
80			// 1. Extension field targets: list of the extended parent message of
81			// every extension.
82			// 2. Extension field dependencies: list of the enum or message type
83			// referred to by every extension field.
84			// 3. Service method inputs: list of the input message type
85			// referred to by every service method.
86			// 4. Service method outputs: list of the output message type
87			// referred to by every service method.
88			//
89			// The offset into DependencyIndexes for the start of each sub-list
90			// is appended to the end in reverse order.
91			DependencyIndexes []int32
92
93			// EnumInfos is a list of enum infos in "flattened ordering".
94			EnumInfos []pimpl.EnumInfo
95
96			// MessageInfos is a list of message infos in "flattened ordering".
97			// If provided, the GoType and PBType for each element is populated.
98			//
99			// Requirement: len(MessageInfos) == len(Build.Messages)
100			MessageInfos []pimpl.MessageInfo
101
102			// ExtensionInfos is a list of extension infos in "flattened ordering".
103			// Each element is initialized and registered with the protoregistry package.
104			//
105			// Requirement: len(LegacyExtensions) == len(Build.Extensions)
106			ExtensionInfos []pimpl.ExtensionInfo
107
108			// TypeRegistry is the registry to register each type descriptor.
109			// If nil, it uses protoregistry.GlobalTypes.
110			TypeRegistry interface {
111			RegisterMessage(pref.MessageType) error
112			RegisterEnum(pref.EnumType) error
113			RegisterExtension(pref.ExtensionType) error
114			}
115			}
116
117			// Out is the output of the builder.
118			type Out struct {
119			File pref.FileDescriptor
120			}
121
122			func (tb Builder) Build() (out Out) {
123			// Replace the resolver with one that resolves dependencies by index,
124			// which is faster and more reliable than relying on the global registry.
125			if tb.File.FileRegistry == nil {
126			tb.File.FileRegistry = preg.GlobalFiles
127			}
128			tb.File.FileRegistry = &resolverByIndex{
129			goTypes: tb.GoTypes,
130			depIdxs: tb.DependencyIndexes,
131			fileRegistry: tb.File.FileRegistry,
132			}
133
134			// Initialize registry if unpopulated.
135			if tb.TypeRegistry == nil {
136			tb.TypeRegistry = preg.GlobalTypes
137			}
138
139			fbOut := tb.File.Build()
140			out.File = fbOut.File
141
142			// Process enums.
143			enumGoTypes := tb.GoTypes[:len(fbOut.Enums)]
144			if len(tb.EnumInfos) != len(fbOut.Enums) {
145			panic("mismatching enum lengths")
146			}
147			if len(fbOut.Enums) > 0 {
148			for i := range fbOut.Enums {
149			tb.EnumInfos[i] = pimpl.EnumInfo{
150			GoReflectType: reflect.TypeOf(enumGoTypes[i]),
151			Desc: &fbOut.Enums[i],
152			}
153			// Register enum types.
154			if err := tb.TypeRegistry.RegisterEnum(&tb.EnumInfos[i]); err != nil {
155			panic(err)
156			}
157			}
158			}
159
160			// Process messages.
161			messageGoTypes := tb.GoTypes[len(fbOut.Enums):][:len(fbOut.Messages)]
162			if len(tb.MessageInfos) != len(fbOut.Messages) {
163			panic("mismatching message lengths")
164			}
165			if len(fbOut.Messages) > 0 {
166			for i := range fbOut.Messages {
167			if messageGoTypes[i] == nil {
168			continue // skip map entry
169			}
170
171			tb.MessageInfos[i].GoReflectType = reflect.TypeOf(messageGoTypes[i])
172			tb.MessageInfos[i].Desc = &fbOut.Messages[i]
173
174			// Register message types.
175			if err := tb.TypeRegistry.RegisterMessage(&tb.MessageInfos[i]); err != nil {
176			panic(err)
177			}
178			}
179
180			// As a special-case for descriptor.proto,
181			// locally register concrete message type for the options.
182			if out.File.Path() == "google/protobuf/descriptor.proto" && out.File.Package() == "google.protobuf" {
183			for i := range fbOut.Messages {
184			switch fbOut.Messages[i].Name() {
185			case "FileOptions":
186			descopts.File = messageGoTypes[i].(pref.ProtoMessage)
187			case "EnumOptions":
188			descopts.Enum = messageGoTypes[i].(pref.ProtoMessage)
189			case "EnumValueOptions":
190			descopts.EnumValue = messageGoTypes[i].(pref.ProtoMessage)
191			case "MessageOptions":
192			descopts.Message = messageGoTypes[i].(pref.ProtoMessage)
193			case "FieldOptions":
194			descopts.Field = messageGoTypes[i].(pref.ProtoMessage)
195			case "OneofOptions":
196			descopts.Oneof = messageGoTypes[i].(pref.ProtoMessage)
197			case "ExtensionRangeOptions":
198			descopts.ExtensionRange = messageGoTypes[i].(pref.ProtoMessage)
199			case "ServiceOptions":
200			descopts.Service = messageGoTypes[i].(pref.ProtoMessage)
201			case "MethodOptions":
202			descopts.Method = messageGoTypes[i].(pref.ProtoMessage)
203			}
204			}
205			}
206			}
207
208			// Process extensions.
209			if len(tb.ExtensionInfos) != len(fbOut.Extensions) {
210			panic("mismatching extension lengths")
211			}
212			var depIdx int32
213			for i := range fbOut.Extensions {
214			// For enum and message kinds, determine the referent Go type so
215			// that we can construct their constructors.
216			const listExtDeps = 2
217			var goType reflect.Type
218			switch fbOut.Extensions[i].L1.Kind {
219			case pref.EnumKind:
220			j := depIdxs.Get(tb.DependencyIndexes, listExtDeps, depIdx)
221			goType = reflect.TypeOf(tb.GoTypes[j])
222			depIdx++
223			case pref.MessageKind, pref.GroupKind:
224			j := depIdxs.Get(tb.DependencyIndexes, listExtDeps, depIdx)
225			goType = reflect.TypeOf(tb.GoTypes[j])
226			depIdx++
227			default:
228			goType = goTypeForPBKind[fbOut.Extensions[i].L1.Kind]
229			}
230			if fbOut.Extensions[i].IsList() {
231			goType = reflect.SliceOf(goType)
232			}
233
234			pimpl.InitExtensionInfo(&tb.ExtensionInfos[i], &fbOut.Extensions[i], goType)
235
236			// Register extension types.
237			if err := tb.TypeRegistry.RegisterExtension(&tb.ExtensionInfos[i]); err != nil {
238			panic(err)
239			}
240			}
241
242			return out
243			}
244
245			var goTypeForPBKind = map[pref.Kind]reflect.Type{
246			pref.BoolKind: reflect.TypeOf(bool(false)),
247			pref.Int32Kind: reflect.TypeOf(int32(0)),
248			pref.Sint32Kind: reflect.TypeOf(int32(0)),
249			pref.Sfixed32Kind: reflect.TypeOf(int32(0)),
250			pref.Int64Kind: reflect.TypeOf(int64(0)),
251			pref.Sint64Kind: reflect.TypeOf(int64(0)),
252			pref.Sfixed64Kind: reflect.TypeOf(int64(0)),
253			pref.Uint32Kind: reflect.TypeOf(uint32(0)),
254			pref.Fixed32Kind: reflect.TypeOf(uint32(0)),
255			pref.Uint64Kind: reflect.TypeOf(uint64(0)),
256			pref.Fixed64Kind: reflect.TypeOf(uint64(0)),
257			pref.FloatKind: reflect.TypeOf(float32(0)),
258			pref.DoubleKind: reflect.TypeOf(float64(0)),
259			pref.StringKind: reflect.TypeOf(string("")),
260			pref.BytesKind: reflect.TypeOf([]byte(nil)),
261			}
262
263			type depIdxs []int32
264
265			// Get retrieves the jth element of the ith sub-list.
266			func (x depIdxs) Get(i, j int32) int32 {
267			return x[x[int32(len(x))-i-1]+j]
268			}
269
270			type (
271			resolverByIndex struct {
272			goTypes []interface{}
273			depIdxs depIdxs
274			fileRegistry
275			}
276			fileRegistry interface {
277			FindFileByPath(string) (pref.FileDescriptor, error)
278			FindDescriptorByName(pref.FullName) (pref.Descriptor, error)
279			RegisterFile(pref.FileDescriptor) error
280			}
281			)
282
283			func (r *resolverByIndex) FindEnumByIndex(i, j int32, es []fdesc.Enum, ms []fdesc.Message) pref.EnumDescriptor {
284			if depIdx := int(r.depIdxs.Get(i, j)); int(depIdx) < len(es)+len(ms) {
285			return &es[depIdx]
286			} else {
287			return pimpl.Export{}.EnumDescriptorOf(r.goTypes[depIdx])
288			}
289			}
290
291			func (r *resolverByIndex) FindMessageByIndex(i, j int32, es []fdesc.Enum, ms []fdesc.Message) pref.MessageDescriptor {
292			if depIdx := int(r.depIdxs.Get(i, j)); depIdx < len(es)+len(ms) {
293			return &ms[depIdx-len(es)]
294			} else {
295			return pimpl.Export{}.MessageDescriptorOf(r.goTypes[depIdx])
296			}
297			}
298

cdleo / go-sqldb

Push — main ( 973aa1...436074 )

filetype.Builder.Build F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like