1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
package internal
import (
"google.golang.org/protobuf/types/descriptorpb"
)
// SourceInfoMap is a map of paths in a descriptor to the corresponding source
// code info.
type SourceInfoMap map[string][]*descriptorpb.SourceCodeInfo_Location
// Get returns the source code info for the given path. If there are
// multiple locations for the same path, the first one is returned.
func (m SourceInfoMap) Get(path []int32) *descriptorpb.SourceCodeInfo_Location {
v := m[asMapKey(path)]
if len(v) > 0 {
return v[0]
}
return nil
}
// GetAll returns all source code info for the given path.
func (m SourceInfoMap) GetAll(path []int32) []*descriptorpb.SourceCodeInfo_Location {
return m[asMapKey(path)]
}
// Add stores the given source code info for the given path.
func (m SourceInfoMap) Add(path []int32, loc *descriptorpb.SourceCodeInfo_Location) {
m[asMapKey(path)] = append(m[asMapKey(path)], loc)
}
// PutIfAbsent stores the given source code info for the given path only if the
// given path does not exist in the map. This method returns true when the value
// is stored, false if the path already exists.
func (m SourceInfoMap) PutIfAbsent(path []int32, loc *descriptorpb.SourceCodeInfo_Location) bool {
k := asMapKey(path)
if _, ok := m[k]; ok {
return false
}
m[k] = []*descriptorpb.SourceCodeInfo_Location{loc}
return true
}
func asMapKey(slice []int32) string {
// NB: arrays should be usable as map keys, but this does not
// work due to a bug: https://github.com/golang/go/issues/22605
//rv := reflect.ValueOf(slice)
//arrayType := reflect.ArrayOf(rv.Len(), rv.Type().Elem())
//array := reflect.New(arrayType).Elem()
//reflect.Copy(array, rv)
//return array.Interface()
b := make([]byte, len(slice)*4)
j := 0
for _, s := range slice {
b[j] = byte(s)
b[j+1] = byte(s >> 8)
b[j+2] = byte(s >> 16)
b[j+3] = byte(s >> 24)
j += 4
}
return string(b)
}
// CreateSourceInfoMap constructs a new SourceInfoMap and populates it with the
// source code info in the given file descriptor proto.
func CreateSourceInfoMap(fd *descriptorpb.FileDescriptorProto) SourceInfoMap {
res := SourceInfoMap{}
PopulateSourceInfoMap(fd, res)
return res
}
// PopulateSourceInfoMap populates the given SourceInfoMap with information from
// the given file descriptor.
func PopulateSourceInfoMap(fd *descriptorpb.FileDescriptorProto, m SourceInfoMap) {
for _, l := range fd.GetSourceCodeInfo().GetLocation() {
m.Add(l.Path, l)
}
}
// NB: This wonkiness allows desc.Descriptor impl to implement an interface that
// is only usable from this package, by embedding a SourceInfoComputeFunc that
// implements the actual logic (which must live in desc package to avoid a
// dependency cycle).
// SourceInfoComputer is a single method which will be invoked to recompute
// source info. This is needed for the protoparse package, which needs to link
// descriptors without source info in order to interpret options, but then needs
// to re-compute source info after that interpretation so that final linked
// descriptors expose the right info.
type SourceInfoComputer interface {
recomputeSourceInfo()
}
// SourceInfoComputeFunc is the type that a desc.Descriptor will embed. It will
// be aliased in the desc package to an unexported name so it is not marked as
// an exported field in reflection and not present in Go docs.
type SourceInfoComputeFunc func()
func (f SourceInfoComputeFunc) recomputeSourceInfo() {
f()
}
// RecomputeSourceInfo is used to initiate recomputation of source info. This is
// is used by the protoparse package, after it interprets options.
func RecomputeSourceInfo(c SourceInfoComputer) {
c.recomputeSourceInfo()
}
|
