| // Copyright 2024 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. |
| |
| // Code generated by protoc-gen-go. DO NOT EDIT. |
| // versions: |
| // protoc-gen-go v1.36.8 |
| // protoc v6.32.0 |
| // source: stats.proto |
| |
| //go:build protoopaque |
| |
| package dashboard |
| |
| import ( |
| protoreflect "google.golang.org/protobuf/reflect/protoreflect" |
| protoimpl "google.golang.org/protobuf/runtime/protoimpl" |
| _ "google.golang.org/protobuf/types/gofeaturespb" |
| reflect "reflect" |
| unsafe "unsafe" |
| ) |
| |
| const ( |
| // Verify that this generated code is sufficiently up-to-date. |
| _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) |
| // Verify that runtime/protoimpl is sufficiently up-to-date. |
| _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) |
| ) |
| |
| // RewriteLevel represents rewrite level after which entries are |
| // collected. For example, GREEN means that the tool does a green |
| // rewrite and analyzes the result to create entries. |
| type RewriteLevel int32 |
| |
| const ( |
| RewriteLevel_REWRITE_LEVEL_UNSPECIFIED RewriteLevel = 0 |
| RewriteLevel_NONE RewriteLevel = 1 |
| RewriteLevel_GREEN RewriteLevel = 2 |
| RewriteLevel_YELLOW RewriteLevel = 3 |
| RewriteLevel_RED RewriteLevel = 4 |
| ) |
| |
| // Enum value maps for RewriteLevel. |
| var ( |
| RewriteLevel_name = map[int32]string{ |
| 0: "REWRITE_LEVEL_UNSPECIFIED", |
| 1: "NONE", |
| 2: "GREEN", |
| 3: "YELLOW", |
| 4: "RED", |
| } |
| RewriteLevel_value = map[string]int32{ |
| "REWRITE_LEVEL_UNSPECIFIED": 0, |
| "NONE": 1, |
| "GREEN": 2, |
| "YELLOW": 3, |
| "RED": 4, |
| } |
| ) |
| |
| func (x RewriteLevel) Enum() *RewriteLevel { |
| p := new(RewriteLevel) |
| *p = x |
| return p |
| } |
| |
| func (x RewriteLevel) String() string { |
| return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) |
| } |
| |
| func (RewriteLevel) Descriptor() protoreflect.EnumDescriptor { |
| return file_stats_proto_enumTypes[0].Descriptor() |
| } |
| |
| func (RewriteLevel) Type() protoreflect.EnumType { |
| return &file_stats_proto_enumTypes[0] |
| } |
| |
| func (x RewriteLevel) Number() protoreflect.EnumNumber { |
| return protoreflect.EnumNumber(x) |
| } |
| |
| type Status_Type int32 |
| |
| const ( |
| Status_UNSPECIFIED_TYPE Status_Type = 0 |
| Status_OK Status_Type = 1 |
| Status_SKIP Status_Type = 2 |
| Status_FAIL Status_Type = 3 |
| ) |
| |
| // Enum value maps for Status_Type. |
| var ( |
| Status_Type_name = map[int32]string{ |
| 0: "UNSPECIFIED_TYPE", |
| 1: "OK", |
| 2: "SKIP", |
| 3: "FAIL", |
| } |
| Status_Type_value = map[string]int32{ |
| "UNSPECIFIED_TYPE": 0, |
| "OK": 1, |
| "SKIP": 2, |
| "FAIL": 3, |
| } |
| ) |
| |
| func (x Status_Type) Enum() *Status_Type { |
| p := new(Status_Type) |
| *p = x |
| return p |
| } |
| |
| func (x Status_Type) String() string { |
| return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) |
| } |
| |
| func (Status_Type) Descriptor() protoreflect.EnumDescriptor { |
| return file_stats_proto_enumTypes[1].Descriptor() |
| } |
| |
| func (Status_Type) Type() protoreflect.EnumType { |
| return &file_stats_proto_enumTypes[1] |
| } |
| |
| func (x Status_Type) Number() protoreflect.EnumNumber { |
| return protoreflect.EnumNumber(x) |
| } |
| |
| type Use_Type int32 |
| |
| const ( |
| Use_TYPE_UNSPECIFIED Use_Type = 0 |
| Use_DIRECT_FIELD_ACCESS Use_Type = 1 |
| Use_METHOD_CALL Use_Type = 2 |
| Use_CONSTRUCTOR Use_Type = 3 |
| Use_CONVERSION Use_Type = 4 |
| Use_TYPE_ASSERTION Use_Type = 5 |
| Use_TYPE_DEFINITION Use_Type = 6 |
| Use_EMBEDDING Use_Type = 7 |
| Use_INTERNAL_FIELD_ACCESS Use_Type = 8 |
| Use_REFLECT_CALL Use_Type = 9 |
| Use_SHALLOW_COPY Use_Type = 10 |
| Use_BUILD_DEPENDENCY Use_Type = 11 |
| ) |
| |
| // Enum value maps for Use_Type. |
| var ( |
| Use_Type_name = map[int32]string{ |
| 0: "TYPE_UNSPECIFIED", |
| 1: "DIRECT_FIELD_ACCESS", |
| 2: "METHOD_CALL", |
| 3: "CONSTRUCTOR", |
| 4: "CONVERSION", |
| 5: "TYPE_ASSERTION", |
| 6: "TYPE_DEFINITION", |
| 7: "EMBEDDING", |
| 8: "INTERNAL_FIELD_ACCESS", |
| 9: "REFLECT_CALL", |
| 10: "SHALLOW_COPY", |
| 11: "BUILD_DEPENDENCY", |
| } |
| Use_Type_value = map[string]int32{ |
| "TYPE_UNSPECIFIED": 0, |
| "DIRECT_FIELD_ACCESS": 1, |
| "METHOD_CALL": 2, |
| "CONSTRUCTOR": 3, |
| "CONVERSION": 4, |
| "TYPE_ASSERTION": 5, |
| "TYPE_DEFINITION": 6, |
| "EMBEDDING": 7, |
| "INTERNAL_FIELD_ACCESS": 8, |
| "REFLECT_CALL": 9, |
| "SHALLOW_COPY": 10, |
| "BUILD_DEPENDENCY": 11, |
| } |
| ) |
| |
| func (x Use_Type) Enum() *Use_Type { |
| p := new(Use_Type) |
| *p = x |
| return p |
| } |
| |
| func (x Use_Type) String() string { |
| return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) |
| } |
| |
| func (Use_Type) Descriptor() protoreflect.EnumDescriptor { |
| return file_stats_proto_enumTypes[2].Descriptor() |
| } |
| |
| func (Use_Type) Type() protoreflect.EnumType { |
| return &file_stats_proto_enumTypes[2] |
| } |
| |
| func (x Use_Type) Number() protoreflect.EnumNumber { |
| return protoreflect.EnumNumber(x) |
| } |
| |
| type MethodCall_Type int32 |
| |
| const ( |
| MethodCall_INVALID MethodCall_Type = 0 |
| MethodCall_GET_ONEOF MethodCall_Type = 1 |
| MethodCall_GET_BUILD MethodCall_Type = 2 |
| ) |
| |
| // Enum value maps for MethodCall_Type. |
| var ( |
| MethodCall_Type_name = map[int32]string{ |
| 0: "INVALID", |
| 1: "GET_ONEOF", |
| 2: "GET_BUILD", |
| } |
| MethodCall_Type_value = map[string]int32{ |
| "INVALID": 0, |
| "GET_ONEOF": 1, |
| "GET_BUILD": 2, |
| } |
| ) |
| |
| func (x MethodCall_Type) Enum() *MethodCall_Type { |
| p := new(MethodCall_Type) |
| *p = x |
| return p |
| } |
| |
| func (x MethodCall_Type) String() string { |
| return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) |
| } |
| |
| func (MethodCall_Type) Descriptor() protoreflect.EnumDescriptor { |
| return file_stats_proto_enumTypes[3].Descriptor() |
| } |
| |
| func (MethodCall_Type) Type() protoreflect.EnumType { |
| return &file_stats_proto_enumTypes[3] |
| } |
| |
| func (x MethodCall_Type) Number() protoreflect.EnumNumber { |
| return protoreflect.EnumNumber(x) |
| } |
| |
| type Constructor_Type int32 |
| |
| const ( |
| Constructor_TYPE_UNSPECIFIED Constructor_Type = 0 |
| Constructor_EMPTY_LITERAL Constructor_Type = 1 |
| Constructor_NONEMPTY_LITERAL Constructor_Type = 2 |
| Constructor_BUILDER Constructor_Type = 3 |
| ) |
| |
| // Enum value maps for Constructor_Type. |
| var ( |
| Constructor_Type_name = map[int32]string{ |
| 0: "TYPE_UNSPECIFIED", |
| 1: "EMPTY_LITERAL", |
| 2: "NONEMPTY_LITERAL", |
| 3: "BUILDER", |
| } |
| Constructor_Type_value = map[string]int32{ |
| "TYPE_UNSPECIFIED": 0, |
| "EMPTY_LITERAL": 1, |
| "NONEMPTY_LITERAL": 2, |
| "BUILDER": 3, |
| } |
| ) |
| |
| func (x Constructor_Type) Enum() *Constructor_Type { |
| p := new(Constructor_Type) |
| *p = x |
| return p |
| } |
| |
| func (x Constructor_Type) String() string { |
| return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) |
| } |
| |
| func (Constructor_Type) Descriptor() protoreflect.EnumDescriptor { |
| return file_stats_proto_enumTypes[4].Descriptor() |
| } |
| |
| func (Constructor_Type) Type() protoreflect.EnumType { |
| return &file_stats_proto_enumTypes[4] |
| } |
| |
| func (x Constructor_Type) Number() protoreflect.EnumNumber { |
| return protoreflect.EnumNumber(x) |
| } |
| |
| type Conversion_Context int32 |
| |
| const ( |
| Conversion_CONTEXT_UNSPECIFIED Conversion_Context = 0 |
| Conversion_CALL_ARGUMENT Conversion_Context = 1 |
| Conversion_RETURN_VALUE Conversion_Context = 2 |
| Conversion_ASSIGNMENT Conversion_Context = 3 |
| Conversion_EXPLICIT Conversion_Context = 4 |
| Conversion_COMPOSITE_LITERAL_ELEMENT Conversion_Context = 5 |
| Conversion_CHAN_SEND Conversion_Context = 6 |
| Conversion_FUNC_RET Conversion_Context = 7 |
| ) |
| |
| // Enum value maps for Conversion_Context. |
| var ( |
| Conversion_Context_name = map[int32]string{ |
| 0: "CONTEXT_UNSPECIFIED", |
| 1: "CALL_ARGUMENT", |
| 2: "RETURN_VALUE", |
| 3: "ASSIGNMENT", |
| 4: "EXPLICIT", |
| 5: "COMPOSITE_LITERAL_ELEMENT", |
| 6: "CHAN_SEND", |
| 7: "FUNC_RET", |
| } |
| Conversion_Context_value = map[string]int32{ |
| "CONTEXT_UNSPECIFIED": 0, |
| "CALL_ARGUMENT": 1, |
| "RETURN_VALUE": 2, |
| "ASSIGNMENT": 3, |
| "EXPLICIT": 4, |
| "COMPOSITE_LITERAL_ELEMENT": 5, |
| "CHAN_SEND": 6, |
| "FUNC_RET": 7, |
| } |
| ) |
| |
| func (x Conversion_Context) Enum() *Conversion_Context { |
| p := new(Conversion_Context) |
| *p = x |
| return p |
| } |
| |
| func (x Conversion_Context) String() string { |
| return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) |
| } |
| |
| func (Conversion_Context) Descriptor() protoreflect.EnumDescriptor { |
| return file_stats_proto_enumTypes[5].Descriptor() |
| } |
| |
| func (Conversion_Context) Type() protoreflect.EnumType { |
| return &file_stats_proto_enumTypes[5] |
| } |
| |
| func (x Conversion_Context) Number() protoreflect.EnumNumber { |
| return protoreflect.EnumNumber(x) |
| } |
| |
| type ShallowCopy_Type int32 |
| |
| const ( |
| ShallowCopy_TYPE_UNSPECIFIED ShallowCopy_Type = 0 |
| ShallowCopy_ASSIGN ShallowCopy_Type = 1 |
| ShallowCopy_CALL_ARGUMENT ShallowCopy_Type = 2 |
| ShallowCopy_FUNC_RET ShallowCopy_Type = 3 |
| ShallowCopy_COMPOSITE_LITERAL_ELEMENT ShallowCopy_Type = 4 |
| ShallowCopy_CHAN_SEND ShallowCopy_Type = 5 |
| ) |
| |
| // Enum value maps for ShallowCopy_Type. |
| var ( |
| ShallowCopy_Type_name = map[int32]string{ |
| 0: "TYPE_UNSPECIFIED", |
| 1: "ASSIGN", |
| 2: "CALL_ARGUMENT", |
| 3: "FUNC_RET", |
| 4: "COMPOSITE_LITERAL_ELEMENT", |
| 5: "CHAN_SEND", |
| } |
| ShallowCopy_Type_value = map[string]int32{ |
| "TYPE_UNSPECIFIED": 0, |
| "ASSIGN": 1, |
| "CALL_ARGUMENT": 2, |
| "FUNC_RET": 3, |
| "COMPOSITE_LITERAL_ELEMENT": 4, |
| "CHAN_SEND": 5, |
| } |
| ) |
| |
| func (x ShallowCopy_Type) Enum() *ShallowCopy_Type { |
| p := new(ShallowCopy_Type) |
| *p = x |
| return p |
| } |
| |
| func (x ShallowCopy_Type) String() string { |
| return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) |
| } |
| |
| func (ShallowCopy_Type) Descriptor() protoreflect.EnumDescriptor { |
| return file_stats_proto_enumTypes[6].Descriptor() |
| } |
| |
| func (ShallowCopy_Type) Type() protoreflect.EnumType { |
| return &file_stats_proto_enumTypes[6] |
| } |
| |
| func (x ShallowCopy_Type) Number() protoreflect.EnumNumber { |
| return protoreflect.EnumNumber(x) |
| } |
| |
| // Entry represents a single usage of a proto type. For example, a |
| // single field access, method call, use as a type, etc. We collect |
| // entries and analyze them offline to generate various statistics |
| // (e.g. number of direct field accesses per package) about the |
| // migration to opaque Go protocol buffer API. |
| type Entry struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_Status *Status `protobuf:"bytes,1,opt,name=status"` |
| xxx_hidden_Location *Location `protobuf:"bytes,2,opt,name=location"` |
| xxx_hidden_Level RewriteLevel `protobuf:"varint,3,opt,name=level,enum=net.proto2.go.open2opaque.stats.RewriteLevel"` |
| xxx_hidden_Type *Type `protobuf:"bytes,4,opt,name=type"` |
| xxx_hidden_Expr *Expression `protobuf:"bytes,5,opt,name=expr"` |
| xxx_hidden_Use *Use `protobuf:"bytes,6,opt,name=use"` |
| xxx_hidden_Source *Source `protobuf:"bytes,7,opt,name=source"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *Entry) Reset() { |
| *x = Entry{} |
| mi := &file_stats_proto_msgTypes[0] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *Entry) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*Entry) ProtoMessage() {} |
| |
| func (x *Entry) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[0] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *Entry) GetStatus() *Status { |
| if x != nil { |
| return x.xxx_hidden_Status |
| } |
| return nil |
| } |
| |
| func (x *Entry) GetLocation() *Location { |
| if x != nil { |
| return x.xxx_hidden_Location |
| } |
| return nil |
| } |
| |
| func (x *Entry) GetLevel() RewriteLevel { |
| if x != nil { |
| return x.xxx_hidden_Level |
| } |
| return RewriteLevel_REWRITE_LEVEL_UNSPECIFIED |
| } |
| |
| func (x *Entry) GetType() *Type { |
| if x != nil { |
| return x.xxx_hidden_Type |
| } |
| return nil |
| } |
| |
| func (x *Entry) GetExpr() *Expression { |
| if x != nil { |
| return x.xxx_hidden_Expr |
| } |
| return nil |
| } |
| |
| func (x *Entry) GetUse() *Use { |
| if x != nil { |
| return x.xxx_hidden_Use |
| } |
| return nil |
| } |
| |
| func (x *Entry) GetSource() *Source { |
| if x != nil { |
| return x.xxx_hidden_Source |
| } |
| return nil |
| } |
| |
| func (x *Entry) SetStatus(v *Status) { |
| x.xxx_hidden_Status = v |
| } |
| |
| func (x *Entry) SetLocation(v *Location) { |
| x.xxx_hidden_Location = v |
| } |
| |
| func (x *Entry) SetLevel(v RewriteLevel) { |
| x.xxx_hidden_Level = v |
| } |
| |
| func (x *Entry) SetType(v *Type) { |
| x.xxx_hidden_Type = v |
| } |
| |
| func (x *Entry) SetExpr(v *Expression) { |
| x.xxx_hidden_Expr = v |
| } |
| |
| func (x *Entry) SetUse(v *Use) { |
| x.xxx_hidden_Use = v |
| } |
| |
| func (x *Entry) SetSource(v *Source) { |
| x.xxx_hidden_Source = v |
| } |
| |
| func (x *Entry) HasStatus() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_Status != nil |
| } |
| |
| func (x *Entry) HasLocation() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_Location != nil |
| } |
| |
| func (x *Entry) HasType() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_Type != nil |
| } |
| |
| func (x *Entry) HasExpr() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_Expr != nil |
| } |
| |
| func (x *Entry) HasUse() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_Use != nil |
| } |
| |
| func (x *Entry) HasSource() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_Source != nil |
| } |
| |
| func (x *Entry) ClearStatus() { |
| x.xxx_hidden_Status = nil |
| } |
| |
| func (x *Entry) ClearLocation() { |
| x.xxx_hidden_Location = nil |
| } |
| |
| func (x *Entry) ClearType() { |
| x.xxx_hidden_Type = nil |
| } |
| |
| func (x *Entry) ClearExpr() { |
| x.xxx_hidden_Expr = nil |
| } |
| |
| func (x *Entry) ClearUse() { |
| x.xxx_hidden_Use = nil |
| } |
| |
| func (x *Entry) ClearSource() { |
| x.xxx_hidden_Source = nil |
| } |
| |
| type Entry_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| // If status is not set or empty then all other fields should be set |
| // and describe a single usage of a protocol buffer type in Go. |
| // |
| // If status is not empty then: |
| // - status.error says what went wrong, and |
| // - location.package says which package couldn't be processed |
| Status *Status |
| // Location in Go code. Always set. Location.package is always |
| // non-empty. |
| Location *Location |
| // Rewrite level after which this entry was captured. |
| Level RewriteLevel |
| // Go type representing a protocol buffer type. |
| Type *Type |
| // Go expression which leads to this entry. |
| Expr *Expression |
| // Describes how a protocol buffer is used (e.g. direct field access). |
| Use *Use |
| // Source of the information. For debugging purposes. |
| Source *Source |
| } |
| |
| func (b0 Entry_builder) Build() *Entry { |
| m0 := &Entry{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_Status = b.Status |
| x.xxx_hidden_Location = b.Location |
| x.xxx_hidden_Level = b.Level |
| x.xxx_hidden_Type = b.Type |
| x.xxx_hidden_Expr = b.Expr |
| x.xxx_hidden_Use = b.Use |
| x.xxx_hidden_Source = b.Source |
| return m0 |
| } |
| |
| // Location represents location of an expression in a Go file. |
| type Location struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_Package string `protobuf:"bytes,1,opt,name=package"` |
| xxx_hidden_File string `protobuf:"bytes,2,opt,name=file"` |
| xxx_hidden_IsGeneratedFile bool `protobuf:"varint,3,opt,name=is_generated_file,json=isGeneratedFile"` |
| xxx_hidden_Start *Position `protobuf:"bytes,4,opt,name=start"` |
| xxx_hidden_End *Position `protobuf:"bytes,5,opt,name=end"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *Location) Reset() { |
| *x = Location{} |
| mi := &file_stats_proto_msgTypes[1] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *Location) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*Location) ProtoMessage() {} |
| |
| func (x *Location) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[1] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *Location) GetPackage() string { |
| if x != nil { |
| return x.xxx_hidden_Package |
| } |
| return "" |
| } |
| |
| func (x *Location) GetFile() string { |
| if x != nil { |
| return x.xxx_hidden_File |
| } |
| return "" |
| } |
| |
| func (x *Location) GetIsGeneratedFile() bool { |
| if x != nil { |
| return x.xxx_hidden_IsGeneratedFile |
| } |
| return false |
| } |
| |
| func (x *Location) GetStart() *Position { |
| if x != nil { |
| return x.xxx_hidden_Start |
| } |
| return nil |
| } |
| |
| func (x *Location) GetEnd() *Position { |
| if x != nil { |
| return x.xxx_hidden_End |
| } |
| return nil |
| } |
| |
| func (x *Location) SetPackage(v string) { |
| x.xxx_hidden_Package = v |
| } |
| |
| func (x *Location) SetFile(v string) { |
| x.xxx_hidden_File = v |
| } |
| |
| func (x *Location) SetIsGeneratedFile(v bool) { |
| x.xxx_hidden_IsGeneratedFile = v |
| } |
| |
| func (x *Location) SetStart(v *Position) { |
| x.xxx_hidden_Start = v |
| } |
| |
| func (x *Location) SetEnd(v *Position) { |
| x.xxx_hidden_End = v |
| } |
| |
| func (x *Location) HasStart() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_Start != nil |
| } |
| |
| func (x *Location) HasEnd() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_End != nil |
| } |
| |
| func (x *Location) ClearStart() { |
| x.xxx_hidden_Start = nil |
| } |
| |
| func (x *Location) ClearEnd() { |
| x.xxx_hidden_End = nil |
| } |
| |
| type Location_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| // Full name of a Go package |
| Package string |
| // path to a Go file |
| File string |
| // Whether the file is a generated file. |
| IsGeneratedFile bool |
| // Start of the expression. |
| Start *Position |
| // End of the expression. |
| End *Position |
| } |
| |
| func (b0 Location_builder) Build() *Location { |
| m0 := &Location{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_Package = b.Package |
| x.xxx_hidden_File = b.File |
| x.xxx_hidden_IsGeneratedFile = b.IsGeneratedFile |
| x.xxx_hidden_Start = b.Start |
| x.xxx_hidden_End = b.End |
| return m0 |
| } |
| |
| // Position describes a position in a Go file. |
| type Position struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_Line int64 `protobuf:"varint,1,opt,name=line"` |
| xxx_hidden_Column int64 `protobuf:"varint,2,opt,name=column"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *Position) Reset() { |
| *x = Position{} |
| mi := &file_stats_proto_msgTypes[2] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *Position) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*Position) ProtoMessage() {} |
| |
| func (x *Position) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[2] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *Position) GetLine() int64 { |
| if x != nil { |
| return x.xxx_hidden_Line |
| } |
| return 0 |
| } |
| |
| func (x *Position) GetColumn() int64 { |
| if x != nil { |
| return x.xxx_hidden_Column |
| } |
| return 0 |
| } |
| |
| func (x *Position) SetLine(v int64) { |
| x.xxx_hidden_Line = v |
| } |
| |
| func (x *Position) SetColumn(v int64) { |
| x.xxx_hidden_Column = v |
| } |
| |
| type Position_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| Line int64 |
| Column int64 |
| } |
| |
| func (b0 Position_builder) Build() *Position { |
| m0 := &Position{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_Line = b.Line |
| x.xxx_hidden_Column = b.Column |
| return m0 |
| } |
| |
| // Status specifies an error that occurred. Empty error indicates |
| // success. |
| type Status struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_Type Status_Type `protobuf:"varint,1,opt,name=type,enum=net.proto2.go.open2opaque.stats.Status_Type"` |
| xxx_hidden_Error string `protobuf:"bytes,2,opt,name=error"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *Status) Reset() { |
| *x = Status{} |
| mi := &file_stats_proto_msgTypes[3] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *Status) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*Status) ProtoMessage() {} |
| |
| func (x *Status) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[3] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *Status) GetType() Status_Type { |
| if x != nil { |
| return x.xxx_hidden_Type |
| } |
| return Status_UNSPECIFIED_TYPE |
| } |
| |
| func (x *Status) GetError() string { |
| if x != nil { |
| return x.xxx_hidden_Error |
| } |
| return "" |
| } |
| |
| func (x *Status) SetType(v Status_Type) { |
| x.xxx_hidden_Type = v |
| } |
| |
| func (x *Status) SetError(v string) { |
| x.xxx_hidden_Error = v |
| } |
| |
| type Status_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| Type Status_Type |
| Error string |
| } |
| |
| func (b0 Status_builder) Build() *Status { |
| m0 := &Status{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_Type = b.Type |
| x.xxx_hidden_Error = b.Error |
| return m0 |
| } |
| |
| // Type represents a Go name for a protocol buffer type. |
| type Type struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_ShortName string `protobuf:"bytes,1,opt,name=short_name,json=shortName"` |
| xxx_hidden_LongName string `protobuf:"bytes,2,opt,name=long_name,json=longName"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *Type) Reset() { |
| *x = Type{} |
| mi := &file_stats_proto_msgTypes[4] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *Type) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*Type) ProtoMessage() {} |
| |
| func (x *Type) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[4] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *Type) GetShortName() string { |
| if x != nil { |
| return x.xxx_hidden_ShortName |
| } |
| return "" |
| } |
| |
| func (x *Type) GetLongName() string { |
| if x != nil { |
| return x.xxx_hidden_LongName |
| } |
| return "" |
| } |
| |
| func (x *Type) SetShortName(v string) { |
| x.xxx_hidden_ShortName = v |
| } |
| |
| func (x *Type) SetLongName(v string) { |
| x.xxx_hidden_LongName = v |
| } |
| |
| type Type_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| // The short name of the Go type representing the protocol buffer |
| // type. For example: "qem_go_proto.QueryEventMessage". |
| ShortName string |
| // A fully qualified name of the Go type representing the protocol |
| // buffer type. |
| LongName string |
| } |
| |
| func (b0 Type_builder) Build() *Type { |
| m0 := &Type{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_ShortName = b.ShortName |
| x.xxx_hidden_LongName = b.LongName |
| return m0 |
| } |
| |
| // Expression describes a Go expression. |
| type Expression struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_Type string `protobuf:"bytes,1,opt,name=type"` |
| xxx_hidden_ParentType string `protobuf:"bytes,2,opt,name=parent_type,json=parentType"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *Expression) Reset() { |
| *x = Expression{} |
| mi := &file_stats_proto_msgTypes[5] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *Expression) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*Expression) ProtoMessage() {} |
| |
| func (x *Expression) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[5] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *Expression) GetType() string { |
| if x != nil { |
| return x.xxx_hidden_Type |
| } |
| return "" |
| } |
| |
| func (x *Expression) GetParentType() string { |
| if x != nil { |
| return x.xxx_hidden_ParentType |
| } |
| return "" |
| } |
| |
| func (x *Expression) SetType(v string) { |
| x.xxx_hidden_Type = v |
| } |
| |
| func (x *Expression) SetParentType(v string) { |
| x.xxx_hidden_ParentType = v |
| } |
| |
| type Expression_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| // go/ast expression type (e.g. "*ast.Ident"). |
| Type string |
| // go/ast expression type of the parent. |
| ParentType string |
| } |
| |
| func (b0 Expression_builder) Build() *Expression { |
| m0 := &Expression{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_Type = b.Type |
| x.xxx_hidden_ParentType = b.ParentType |
| return m0 |
| } |
| |
| // Use describes a use of a protocol buffer type in Go. |
| type Use struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_Type Use_Type `protobuf:"varint,1,opt,name=type,enum=net.proto2.go.open2opaque.stats.Use_Type"` |
| xxx_hidden_DirectFieldAccess *FieldAccess `protobuf:"bytes,2,opt,name=direct_field_access,json=directFieldAccess"` |
| xxx_hidden_MethodCall *MethodCall `protobuf:"bytes,3,opt,name=method_call,json=methodCall"` |
| xxx_hidden_Constructor *Constructor `protobuf:"bytes,4,opt,name=constructor"` |
| xxx_hidden_Conversion *Conversion `protobuf:"bytes,5,opt,name=conversion"` |
| xxx_hidden_FuncArg *FuncArg `protobuf:"bytes,6,opt,name=func_arg,json=funcArg"` |
| xxx_hidden_TypeAssertion *TypeAssertion `protobuf:"bytes,7,opt,name=type_assertion,json=typeAssertion"` |
| xxx_hidden_TypeDefinition *TypeDefinition `protobuf:"bytes,8,opt,name=type_definition,json=typeDefinition"` |
| xxx_hidden_Embedding *Embedding `protobuf:"bytes,9,opt,name=embedding"` |
| xxx_hidden_InternalFieldAccess *FieldAccess `protobuf:"bytes,10,opt,name=internal_field_access,json=internalFieldAccess"` |
| xxx_hidden_ReflectCall *ReflectCall `protobuf:"bytes,11,opt,name=reflect_call,json=reflectCall"` |
| xxx_hidden_ShallowCopy *ShallowCopy `protobuf:"bytes,12,opt,name=shallow_copy,json=shallowCopy"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *Use) Reset() { |
| *x = Use{} |
| mi := &file_stats_proto_msgTypes[6] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *Use) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*Use) ProtoMessage() {} |
| |
| func (x *Use) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[6] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *Use) GetType() Use_Type { |
| if x != nil { |
| return x.xxx_hidden_Type |
| } |
| return Use_TYPE_UNSPECIFIED |
| } |
| |
| func (x *Use) GetDirectFieldAccess() *FieldAccess { |
| if x != nil { |
| return x.xxx_hidden_DirectFieldAccess |
| } |
| return nil |
| } |
| |
| func (x *Use) GetMethodCall() *MethodCall { |
| if x != nil { |
| return x.xxx_hidden_MethodCall |
| } |
| return nil |
| } |
| |
| func (x *Use) GetConstructor() *Constructor { |
| if x != nil { |
| return x.xxx_hidden_Constructor |
| } |
| return nil |
| } |
| |
| func (x *Use) GetConversion() *Conversion { |
| if x != nil { |
| return x.xxx_hidden_Conversion |
| } |
| return nil |
| } |
| |
| func (x *Use) GetFuncArg() *FuncArg { |
| if x != nil { |
| return x.xxx_hidden_FuncArg |
| } |
| return nil |
| } |
| |
| func (x *Use) GetTypeAssertion() *TypeAssertion { |
| if x != nil { |
| return x.xxx_hidden_TypeAssertion |
| } |
| return nil |
| } |
| |
| func (x *Use) GetTypeDefinition() *TypeDefinition { |
| if x != nil { |
| return x.xxx_hidden_TypeDefinition |
| } |
| return nil |
| } |
| |
| func (x *Use) GetEmbedding() *Embedding { |
| if x != nil { |
| return x.xxx_hidden_Embedding |
| } |
| return nil |
| } |
| |
| func (x *Use) GetInternalFieldAccess() *FieldAccess { |
| if x != nil { |
| return x.xxx_hidden_InternalFieldAccess |
| } |
| return nil |
| } |
| |
| func (x *Use) GetReflectCall() *ReflectCall { |
| if x != nil { |
| return x.xxx_hidden_ReflectCall |
| } |
| return nil |
| } |
| |
| func (x *Use) GetShallowCopy() *ShallowCopy { |
| if x != nil { |
| return x.xxx_hidden_ShallowCopy |
| } |
| return nil |
| } |
| |
| func (x *Use) SetType(v Use_Type) { |
| x.xxx_hidden_Type = v |
| } |
| |
| func (x *Use) SetDirectFieldAccess(v *FieldAccess) { |
| x.xxx_hidden_DirectFieldAccess = v |
| } |
| |
| func (x *Use) SetMethodCall(v *MethodCall) { |
| x.xxx_hidden_MethodCall = v |
| } |
| |
| func (x *Use) SetConstructor(v *Constructor) { |
| x.xxx_hidden_Constructor = v |
| } |
| |
| func (x *Use) SetConversion(v *Conversion) { |
| x.xxx_hidden_Conversion = v |
| } |
| |
| func (x *Use) SetFuncArg(v *FuncArg) { |
| x.xxx_hidden_FuncArg = v |
| } |
| |
| func (x *Use) SetTypeAssertion(v *TypeAssertion) { |
| x.xxx_hidden_TypeAssertion = v |
| } |
| |
| func (x *Use) SetTypeDefinition(v *TypeDefinition) { |
| x.xxx_hidden_TypeDefinition = v |
| } |
| |
| func (x *Use) SetEmbedding(v *Embedding) { |
| x.xxx_hidden_Embedding = v |
| } |
| |
| func (x *Use) SetInternalFieldAccess(v *FieldAccess) { |
| x.xxx_hidden_InternalFieldAccess = v |
| } |
| |
| func (x *Use) SetReflectCall(v *ReflectCall) { |
| x.xxx_hidden_ReflectCall = v |
| } |
| |
| func (x *Use) SetShallowCopy(v *ShallowCopy) { |
| x.xxx_hidden_ShallowCopy = v |
| } |
| |
| func (x *Use) HasDirectFieldAccess() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_DirectFieldAccess != nil |
| } |
| |
| func (x *Use) HasMethodCall() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_MethodCall != nil |
| } |
| |
| func (x *Use) HasConstructor() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_Constructor != nil |
| } |
| |
| func (x *Use) HasConversion() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_Conversion != nil |
| } |
| |
| func (x *Use) HasFuncArg() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_FuncArg != nil |
| } |
| |
| func (x *Use) HasTypeAssertion() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_TypeAssertion != nil |
| } |
| |
| func (x *Use) HasTypeDefinition() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_TypeDefinition != nil |
| } |
| |
| func (x *Use) HasEmbedding() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_Embedding != nil |
| } |
| |
| func (x *Use) HasInternalFieldAccess() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_InternalFieldAccess != nil |
| } |
| |
| func (x *Use) HasReflectCall() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_ReflectCall != nil |
| } |
| |
| func (x *Use) HasShallowCopy() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_ShallowCopy != nil |
| } |
| |
| func (x *Use) ClearDirectFieldAccess() { |
| x.xxx_hidden_DirectFieldAccess = nil |
| } |
| |
| func (x *Use) ClearMethodCall() { |
| x.xxx_hidden_MethodCall = nil |
| } |
| |
| func (x *Use) ClearConstructor() { |
| x.xxx_hidden_Constructor = nil |
| } |
| |
| func (x *Use) ClearConversion() { |
| x.xxx_hidden_Conversion = nil |
| } |
| |
| func (x *Use) ClearFuncArg() { |
| x.xxx_hidden_FuncArg = nil |
| } |
| |
| func (x *Use) ClearTypeAssertion() { |
| x.xxx_hidden_TypeAssertion = nil |
| } |
| |
| func (x *Use) ClearTypeDefinition() { |
| x.xxx_hidden_TypeDefinition = nil |
| } |
| |
| func (x *Use) ClearEmbedding() { |
| x.xxx_hidden_Embedding = nil |
| } |
| |
| func (x *Use) ClearInternalFieldAccess() { |
| x.xxx_hidden_InternalFieldAccess = nil |
| } |
| |
| func (x *Use) ClearReflectCall() { |
| x.xxx_hidden_ReflectCall = nil |
| } |
| |
| func (x *Use) ClearShallowCopy() { |
| x.xxx_hidden_ShallowCopy = nil |
| } |
| |
| type Use_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| Type Use_Type |
| DirectFieldAccess *FieldAccess |
| MethodCall *MethodCall |
| Constructor *Constructor |
| Conversion *Conversion |
| FuncArg *FuncArg |
| TypeAssertion *TypeAssertion |
| TypeDefinition *TypeDefinition |
| Embedding *Embedding |
| InternalFieldAccess *FieldAccess |
| ReflectCall *ReflectCall |
| ShallowCopy *ShallowCopy |
| } |
| |
| func (b0 Use_builder) Build() *Use { |
| m0 := &Use{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_Type = b.Type |
| x.xxx_hidden_DirectFieldAccess = b.DirectFieldAccess |
| x.xxx_hidden_MethodCall = b.MethodCall |
| x.xxx_hidden_Constructor = b.Constructor |
| x.xxx_hidden_Conversion = b.Conversion |
| x.xxx_hidden_FuncArg = b.FuncArg |
| x.xxx_hidden_TypeAssertion = b.TypeAssertion |
| x.xxx_hidden_TypeDefinition = b.TypeDefinition |
| x.xxx_hidden_Embedding = b.Embedding |
| x.xxx_hidden_InternalFieldAccess = b.InternalFieldAccess |
| x.xxx_hidden_ReflectCall = b.ReflectCall |
| x.xxx_hidden_ShallowCopy = b.ShallowCopy |
| return m0 |
| } |
| |
| // ReflectCall represents a call to the Go reflection API. |
| type ReflectCall struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_Frames *[]*Frame `protobuf:"bytes,1,rep,name=frames"` |
| xxx_hidden_Fn *Frame `protobuf:"bytes,2,opt,name=fn"` |
| xxx_hidden_Caller *Frame `protobuf:"bytes,3,opt,name=caller"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *ReflectCall) Reset() { |
| *x = ReflectCall{} |
| mi := &file_stats_proto_msgTypes[7] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *ReflectCall) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*ReflectCall) ProtoMessage() {} |
| |
| func (x *ReflectCall) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[7] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *ReflectCall) GetFrames() []*Frame { |
| if x != nil { |
| if x.xxx_hidden_Frames != nil { |
| return *x.xxx_hidden_Frames |
| } |
| } |
| return nil |
| } |
| |
| func (x *ReflectCall) GetFn() *Frame { |
| if x != nil { |
| return x.xxx_hidden_Fn |
| } |
| return nil |
| } |
| |
| func (x *ReflectCall) GetCaller() *Frame { |
| if x != nil { |
| return x.xxx_hidden_Caller |
| } |
| return nil |
| } |
| |
| func (x *ReflectCall) SetFrames(v []*Frame) { |
| x.xxx_hidden_Frames = &v |
| } |
| |
| func (x *ReflectCall) SetFn(v *Frame) { |
| x.xxx_hidden_Fn = v |
| } |
| |
| func (x *ReflectCall) SetCaller(v *Frame) { |
| x.xxx_hidden_Caller = v |
| } |
| |
| func (x *ReflectCall) HasFn() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_Fn != nil |
| } |
| |
| func (x *ReflectCall) HasCaller() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_Caller != nil |
| } |
| |
| func (x *ReflectCall) ClearFn() { |
| x.xxx_hidden_Fn = nil |
| } |
| |
| func (x *ReflectCall) ClearCaller() { |
| x.xxx_hidden_Caller = nil |
| } |
| |
| type ReflectCall_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| // Information about all frames leading to the reflection call. |
| // |
| // A callstack usually looks like: |
| // |
| // reflect.Value.Field // the function triggering the log |
| // reflect.F1 // more functions |
| // ... // in the |
| // reflect.Fn // reflect package |
| // import/path.Caller // (1) fn: calls into the reflect package |
| // import/path.C1 // more functions |
| // ... // in the same package |
| // import/path.Cn1 // as fn |
| // ancestor/import.Ancestor // (2) caller: calls into fn's package |
| // ... // more frames |
| // |
| // The frames field has information about all frames but we also |
| // store a few selected frames separately to make it easier to write |
| // queries: |
| // |
| // (1) caller is the last function before the reflection package |
| // (2) ancestor is the last function from a different package than caller |
| // |
| // The frames field contains at least one frame (a function in the |
| // reflect package) but fn and caller may be unset. |
| Frames []*Frame |
| Fn *Frame |
| Caller *Frame |
| } |
| |
| func (b0 ReflectCall_builder) Build() *ReflectCall { |
| m0 := &ReflectCall{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_Frames = &b.Frames |
| x.xxx_hidden_Fn = b.Fn |
| x.xxx_hidden_Caller = b.Caller |
| return m0 |
| } |
| |
| // Frame represents information about a single frame in a Go |
| // stacktrace. |
| type Frame struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_Function string `protobuf:"bytes,1,opt,name=function"` |
| xxx_hidden_IsExported bool `protobuf:"varint,6,opt,name=is_exported,json=isExported"` |
| xxx_hidden_Package string `protobuf:"bytes,2,opt,name=package"` |
| xxx_hidden_File string `protobuf:"bytes,3,opt,name=file"` |
| xxx_hidden_Line string `protobuf:"bytes,4,opt,name=line"` |
| xxx_hidden_Index int64 `protobuf:"varint,5,opt,name=index"` |
| xxx_hidden_PkgIndex int64 `protobuf:"varint,7,opt,name=pkg_index,json=pkgIndex"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *Frame) Reset() { |
| *x = Frame{} |
| mi := &file_stats_proto_msgTypes[8] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *Frame) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*Frame) ProtoMessage() {} |
| |
| func (x *Frame) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[8] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *Frame) GetFunction() string { |
| if x != nil { |
| return x.xxx_hidden_Function |
| } |
| return "" |
| } |
| |
| func (x *Frame) GetIsExported() bool { |
| if x != nil { |
| return x.xxx_hidden_IsExported |
| } |
| return false |
| } |
| |
| func (x *Frame) GetPackage() string { |
| if x != nil { |
| return x.xxx_hidden_Package |
| } |
| return "" |
| } |
| |
| func (x *Frame) GetFile() string { |
| if x != nil { |
| return x.xxx_hidden_File |
| } |
| return "" |
| } |
| |
| func (x *Frame) GetLine() string { |
| if x != nil { |
| return x.xxx_hidden_Line |
| } |
| return "" |
| } |
| |
| func (x *Frame) GetIndex() int64 { |
| if x != nil { |
| return x.xxx_hidden_Index |
| } |
| return 0 |
| } |
| |
| func (x *Frame) GetPkgIndex() int64 { |
| if x != nil { |
| return x.xxx_hidden_PkgIndex |
| } |
| return 0 |
| } |
| |
| func (x *Frame) SetFunction(v string) { |
| x.xxx_hidden_Function = v |
| } |
| |
| func (x *Frame) SetIsExported(v bool) { |
| x.xxx_hidden_IsExported = v |
| } |
| |
| func (x *Frame) SetPackage(v string) { |
| x.xxx_hidden_Package = v |
| } |
| |
| func (x *Frame) SetFile(v string) { |
| x.xxx_hidden_File = v |
| } |
| |
| func (x *Frame) SetLine(v string) { |
| x.xxx_hidden_Line = v |
| } |
| |
| func (x *Frame) SetIndex(v int64) { |
| x.xxx_hidden_Index = v |
| } |
| |
| func (x *Frame) SetPkgIndex(v int64) { |
| x.xxx_hidden_PkgIndex = v |
| } |
| |
| type Frame_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| // Fully qualified function name. For example: |
| // |
| // net/http.Error |
| Function string |
| // true if the function is exported. |
| IsExported bool |
| // Packed in which the function is defined. |
| Package string |
| // path to the source file defining the function. |
| // |
| // For standard-library, the path is relative to the src/ |
| // directory (e.g. net/http/server.go). |
| File string |
| // Line number, together with file, is the location where function |
| // is defined. |
| Line string |
| // index of the frame in the reflect_call.frames repeated field. |
| // |
| // This exists to make SQL queries easier. |
| Index int64 |
| // index of the frame across consecutive frames in the same package. |
| // |
| // This exists to make SQL queries easier. |
| PkgIndex int64 |
| } |
| |
| func (b0 Frame_builder) Build() *Frame { |
| m0 := &Frame{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_Function = b.Function |
| x.xxx_hidden_IsExported = b.IsExported |
| x.xxx_hidden_Package = b.Package |
| x.xxx_hidden_File = b.File |
| x.xxx_hidden_Line = b.Line |
| x.xxx_hidden_Index = b.Index |
| x.xxx_hidden_PkgIndex = b.PkgIndex |
| return m0 |
| } |
| |
| type FieldAccess struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_FieldName string `protobuf:"bytes,1,opt,name=field_name,json=fieldName"` |
| xxx_hidden_FieldType *Type `protobuf:"bytes,2,opt,name=field_type,json=fieldType"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *FieldAccess) Reset() { |
| *x = FieldAccess{} |
| mi := &file_stats_proto_msgTypes[9] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *FieldAccess) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*FieldAccess) ProtoMessage() {} |
| |
| func (x *FieldAccess) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[9] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *FieldAccess) GetFieldName() string { |
| if x != nil { |
| return x.xxx_hidden_FieldName |
| } |
| return "" |
| } |
| |
| func (x *FieldAccess) GetFieldType() *Type { |
| if x != nil { |
| return x.xxx_hidden_FieldType |
| } |
| return nil |
| } |
| |
| func (x *FieldAccess) SetFieldName(v string) { |
| x.xxx_hidden_FieldName = v |
| } |
| |
| func (x *FieldAccess) SetFieldType(v *Type) { |
| x.xxx_hidden_FieldType = v |
| } |
| |
| func (x *FieldAccess) HasFieldType() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_FieldType != nil |
| } |
| |
| func (x *FieldAccess) ClearFieldType() { |
| x.xxx_hidden_FieldType = nil |
| } |
| |
| type FieldAccess_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| FieldName string |
| FieldType *Type |
| } |
| |
| func (b0 FieldAccess_builder) Build() *FieldAccess { |
| m0 := &FieldAccess{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_FieldName = b.FieldName |
| x.xxx_hidden_FieldType = b.FieldType |
| return m0 |
| } |
| |
| type MethodCall struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_Method string `protobuf:"bytes,1,opt,name=method"` |
| xxx_hidden_Type MethodCall_Type `protobuf:"varint,2,opt,name=type,enum=net.proto2.go.open2opaque.stats.MethodCall_Type"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *MethodCall) Reset() { |
| *x = MethodCall{} |
| mi := &file_stats_proto_msgTypes[10] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *MethodCall) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*MethodCall) ProtoMessage() {} |
| |
| func (x *MethodCall) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[10] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *MethodCall) GetMethod() string { |
| if x != nil { |
| return x.xxx_hidden_Method |
| } |
| return "" |
| } |
| |
| func (x *MethodCall) GetType() MethodCall_Type { |
| if x != nil { |
| return x.xxx_hidden_Type |
| } |
| return MethodCall_INVALID |
| } |
| |
| func (x *MethodCall) SetMethod(v string) { |
| x.xxx_hidden_Method = v |
| } |
| |
| func (x *MethodCall) SetType(v MethodCall_Type) { |
| x.xxx_hidden_Type = v |
| } |
| |
| type MethodCall_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| Method string |
| Type MethodCall_Type |
| } |
| |
| func (b0 MethodCall_builder) Build() *MethodCall { |
| m0 := &MethodCall{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_Method = b.Method |
| x.xxx_hidden_Type = b.Type |
| return m0 |
| } |
| |
| type Constructor struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_Type Constructor_Type `protobuf:"varint,1,opt,name=type,enum=net.proto2.go.open2opaque.stats.Constructor_Type"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *Constructor) Reset() { |
| *x = Constructor{} |
| mi := &file_stats_proto_msgTypes[11] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *Constructor) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*Constructor) ProtoMessage() {} |
| |
| func (x *Constructor) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[11] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *Constructor) GetType() Constructor_Type { |
| if x != nil { |
| return x.xxx_hidden_Type |
| } |
| return Constructor_TYPE_UNSPECIFIED |
| } |
| |
| func (x *Constructor) SetType(v Constructor_Type) { |
| x.xxx_hidden_Type = v |
| } |
| |
| type Constructor_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| Type Constructor_Type |
| } |
| |
| func (b0 Constructor_builder) Build() *Constructor { |
| m0 := &Constructor{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_Type = b.Type |
| return m0 |
| } |
| |
| type Conversion struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_DestTypeName string `protobuf:"bytes,1,opt,name=dest_type_name,json=destTypeName"` |
| xxx_hidden_FuncArg *FuncArg `protobuf:"bytes,3,opt,name=func_arg,json=funcArg"` |
| xxx_hidden_Context Conversion_Context `protobuf:"varint,2,opt,name=context,enum=net.proto2.go.open2opaque.stats.Conversion_Context"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *Conversion) Reset() { |
| *x = Conversion{} |
| mi := &file_stats_proto_msgTypes[12] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *Conversion) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*Conversion) ProtoMessage() {} |
| |
| func (x *Conversion) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[12] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *Conversion) GetDestTypeName() string { |
| if x != nil { |
| return x.xxx_hidden_DestTypeName |
| } |
| return "" |
| } |
| |
| func (x *Conversion) GetFuncArg() *FuncArg { |
| if x != nil { |
| return x.xxx_hidden_FuncArg |
| } |
| return nil |
| } |
| |
| func (x *Conversion) GetContext() Conversion_Context { |
| if x != nil { |
| return x.xxx_hidden_Context |
| } |
| return Conversion_CONTEXT_UNSPECIFIED |
| } |
| |
| func (x *Conversion) SetDestTypeName(v string) { |
| x.xxx_hidden_DestTypeName = v |
| } |
| |
| func (x *Conversion) SetFuncArg(v *FuncArg) { |
| x.xxx_hidden_FuncArg = v |
| } |
| |
| func (x *Conversion) SetContext(v Conversion_Context) { |
| x.xxx_hidden_Context = v |
| } |
| |
| func (x *Conversion) HasFuncArg() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_FuncArg != nil |
| } |
| |
| func (x *Conversion) ClearFuncArg() { |
| x.xxx_hidden_FuncArg = nil |
| } |
| |
| type Conversion_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| // The type of the conversion. For example: |
| // |
| // interface{} |
| // proto.Message |
| // unsafe.Pointer |
| DestTypeName string |
| // Describes the called function. It is set if context==CALL_ARGUMENT. |
| FuncArg *FuncArg |
| Context Conversion_Context |
| } |
| |
| func (b0 Conversion_builder) Build() *Conversion { |
| m0 := &Conversion{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_DestTypeName = b.DestTypeName |
| x.xxx_hidden_FuncArg = b.FuncArg |
| x.xxx_hidden_Context = b.Context |
| return m0 |
| } |
| |
| type FuncArg struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_FunctionName string `protobuf:"bytes,1,opt,name=function_name,json=functionName"` |
| xxx_hidden_PackagePath string `protobuf:"bytes,2,opt,name=package_path,json=packagePath"` |
| xxx_hidden_Signature string `protobuf:"bytes,3,opt,name=signature"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *FuncArg) Reset() { |
| *x = FuncArg{} |
| mi := &file_stats_proto_msgTypes[13] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *FuncArg) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*FuncArg) ProtoMessage() {} |
| |
| func (x *FuncArg) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[13] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *FuncArg) GetFunctionName() string { |
| if x != nil { |
| return x.xxx_hidden_FunctionName |
| } |
| return "" |
| } |
| |
| func (x *FuncArg) GetPackagePath() string { |
| if x != nil { |
| return x.xxx_hidden_PackagePath |
| } |
| return "" |
| } |
| |
| func (x *FuncArg) GetSignature() string { |
| if x != nil { |
| return x.xxx_hidden_Signature |
| } |
| return "" |
| } |
| |
| func (x *FuncArg) SetFunctionName(v string) { |
| x.xxx_hidden_FunctionName = v |
| } |
| |
| func (x *FuncArg) SetPackagePath(v string) { |
| x.xxx_hidden_PackagePath = v |
| } |
| |
| func (x *FuncArg) SetSignature(v string) { |
| x.xxx_hidden_Signature = v |
| } |
| |
| type FuncArg_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| // The name of the called function. |
| // For example: "Clone". |
| // |
| // An empty string means that analysis couldn't determine which |
| // function is called (this could happen for indirect calls). |
| FunctionName string |
| // Full package path containing the called function. |
| // |
| // An empty string means that analysis couldn't determine which |
| // function is called (this could happen for indirect calls). |
| PackagePath string |
| // Signature of the called function. |
| // For example: "func(m interface{}) interface{}". |
| Signature string |
| } |
| |
| func (b0 FuncArg_builder) Build() *FuncArg { |
| m0 := &FuncArg{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_FunctionName = b.FunctionName |
| x.xxx_hidden_PackagePath = b.PackagePath |
| x.xxx_hidden_Signature = b.Signature |
| return m0 |
| } |
| |
| type TypeAssertion struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_SrcType *Type `protobuf:"bytes,1,opt,name=src_type,json=srcType"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *TypeAssertion) Reset() { |
| *x = TypeAssertion{} |
| mi := &file_stats_proto_msgTypes[14] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *TypeAssertion) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*TypeAssertion) ProtoMessage() {} |
| |
| func (x *TypeAssertion) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[14] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *TypeAssertion) GetSrcType() *Type { |
| if x != nil { |
| return x.xxx_hidden_SrcType |
| } |
| return nil |
| } |
| |
| func (x *TypeAssertion) SetSrcType(v *Type) { |
| x.xxx_hidden_SrcType = v |
| } |
| |
| func (x *TypeAssertion) HasSrcType() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_SrcType != nil |
| } |
| |
| func (x *TypeAssertion) ClearSrcType() { |
| x.xxx_hidden_SrcType = nil |
| } |
| |
| type TypeAssertion_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| // The type of the expression whose type is being asserted. |
| SrcType *Type |
| } |
| |
| func (b0 TypeAssertion_builder) Build() *TypeAssertion { |
| m0 := &TypeAssertion{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_SrcType = b.SrcType |
| return m0 |
| } |
| |
| type TypeDefinition struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_NewType *Type `protobuf:"bytes,1,opt,name=new_type,json=newType"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *TypeDefinition) Reset() { |
| *x = TypeDefinition{} |
| mi := &file_stats_proto_msgTypes[15] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *TypeDefinition) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*TypeDefinition) ProtoMessage() {} |
| |
| func (x *TypeDefinition) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[15] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *TypeDefinition) GetNewType() *Type { |
| if x != nil { |
| return x.xxx_hidden_NewType |
| } |
| return nil |
| } |
| |
| func (x *TypeDefinition) SetNewType(v *Type) { |
| x.xxx_hidden_NewType = v |
| } |
| |
| func (x *TypeDefinition) HasNewType() bool { |
| if x == nil { |
| return false |
| } |
| return x.xxx_hidden_NewType != nil |
| } |
| |
| func (x *TypeDefinition) ClearNewType() { |
| x.xxx_hidden_NewType = nil |
| } |
| |
| type TypeDefinition_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| // new_type describes the newly defined type. |
| NewType *Type |
| } |
| |
| func (b0 TypeDefinition_builder) Build() *TypeDefinition { |
| m0 := &TypeDefinition{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_NewType = b.NewType |
| return m0 |
| } |
| |
| type Embedding struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_FieldIndex int64 `protobuf:"varint,1,opt,name=field_index,json=fieldIndex"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *Embedding) Reset() { |
| *x = Embedding{} |
| mi := &file_stats_proto_msgTypes[16] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *Embedding) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*Embedding) ProtoMessage() {} |
| |
| func (x *Embedding) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[16] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *Embedding) GetFieldIndex() int64 { |
| if x != nil { |
| return x.xxx_hidden_FieldIndex |
| } |
| return 0 |
| } |
| |
| func (x *Embedding) SetFieldIndex(v int64) { |
| x.xxx_hidden_FieldIndex = v |
| } |
| |
| type Embedding_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| FieldIndex int64 |
| } |
| |
| func (b0 Embedding_builder) Build() *Embedding { |
| m0 := &Embedding{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_FieldIndex = b.FieldIndex |
| return m0 |
| } |
| |
| type Source struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_File string `protobuf:"bytes,1,opt,name=file"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *Source) Reset() { |
| *x = Source{} |
| mi := &file_stats_proto_msgTypes[17] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *Source) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*Source) ProtoMessage() {} |
| |
| func (x *Source) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[17] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *Source) GetFile() string { |
| if x != nil { |
| return x.xxx_hidden_File |
| } |
| return "" |
| } |
| |
| func (x *Source) SetFile(v string) { |
| x.xxx_hidden_File = v |
| } |
| |
| type Source_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| File string |
| } |
| |
| func (b0 Source_builder) Build() *Source { |
| m0 := &Source{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_File = b.File |
| return m0 |
| } |
| |
| // ShallowCopy represents a shallow copy of protocol buffers. |
| // |
| // For example: "*m2 = *m1" for m1, m2 being protocol buffer messages |
| // (pointers to Go structs generated by the proto generor). |
| type ShallowCopy struct { |
| state protoimpl.MessageState `protogen:"opaque.v1"` |
| xxx_hidden_Type ShallowCopy_Type `protobuf:"varint,1,opt,name=type,enum=net.proto2.go.open2opaque.stats.ShallowCopy_Type"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *ShallowCopy) Reset() { |
| *x = ShallowCopy{} |
| mi := &file_stats_proto_msgTypes[18] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *ShallowCopy) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*ShallowCopy) ProtoMessage() {} |
| |
| func (x *ShallowCopy) ProtoReflect() protoreflect.Message { |
| mi := &file_stats_proto_msgTypes[18] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *ShallowCopy) GetType() ShallowCopy_Type { |
| if x != nil { |
| return x.xxx_hidden_Type |
| } |
| return ShallowCopy_TYPE_UNSPECIFIED |
| } |
| |
| func (x *ShallowCopy) SetType(v ShallowCopy_Type) { |
| x.xxx_hidden_Type = v |
| } |
| |
| type ShallowCopy_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| Type ShallowCopy_Type |
| } |
| |
| func (b0 ShallowCopy_builder) Build() *ShallowCopy { |
| m0 := &ShallowCopy{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.xxx_hidden_Type = b.Type |
| return m0 |
| } |
| |
| var File_stats_proto protoreflect.FileDescriptor |
| |
| const file_stats_proto_rawDesc = "" + |
| "\n" + |
| "\vstats.proto\x12\x1fnet.proto2.go.open2opaque.stats\x1a!google/protobuf/go_features.proto\"\xc9\x03\n" + |
| "\x05Entry\x12?\n" + |
| "\x06status\x18\x01 \x01(\v2'.net.proto2.go.open2opaque.stats.StatusR\x06status\x12E\n" + |
| "\blocation\x18\x02 \x01(\v2).net.proto2.go.open2opaque.stats.LocationR\blocation\x12C\n" + |
| "\x05level\x18\x03 \x01(\x0e2-.net.proto2.go.open2opaque.stats.RewriteLevelR\x05level\x129\n" + |
| "\x04type\x18\x04 \x01(\v2%.net.proto2.go.open2opaque.stats.TypeR\x04type\x12?\n" + |
| "\x04expr\x18\x05 \x01(\v2+.net.proto2.go.open2opaque.stats.ExpressionR\x04expr\x126\n" + |
| "\x03use\x18\x06 \x01(\v2$.net.proto2.go.open2opaque.stats.UseR\x03use\x12?\n" + |
| "\x06source\x18\a \x01(\v2'.net.proto2.go.open2opaque.stats.SourceR\x06source\"\xe2\x01\n" + |
| "\bLocation\x12\x18\n" + |
| "\apackage\x18\x01 \x01(\tR\apackage\x12\x12\n" + |
| "\x04file\x18\x02 \x01(\tR\x04file\x12*\n" + |
| "\x11is_generated_file\x18\x03 \x01(\bR\x0fisGeneratedFile\x12?\n" + |
| "\x05start\x18\x04 \x01(\v2).net.proto2.go.open2opaque.stats.PositionR\x05start\x12;\n" + |
| "\x03end\x18\x05 \x01(\v2).net.proto2.go.open2opaque.stats.PositionR\x03end\"6\n" + |
| "\bPosition\x12\x12\n" + |
| "\x04line\x18\x01 \x01(\x03R\x04line\x12\x16\n" + |
| "\x06column\x18\x02 \x01(\x03R\x06column\"\x9a\x01\n" + |
| "\x06Status\x12@\n" + |
| "\x04type\x18\x01 \x01(\x0e2,.net.proto2.go.open2opaque.stats.Status.TypeR\x04type\x12\x14\n" + |
| "\x05error\x18\x02 \x01(\tR\x05error\"8\n" + |
| "\x04Type\x12\x14\n" + |
| "\x10UNSPECIFIED_TYPE\x10\x00\x12\x06\n" + |
| "\x02OK\x10\x01\x12\b\n" + |
| "\x04SKIP\x10\x02\x12\b\n" + |
| "\x04FAIL\x10\x03\"B\n" + |
| "\x04Type\x12\x1d\n" + |
| "\n" + |
| "short_name\x18\x01 \x01(\tR\tshortName\x12\x1b\n" + |
| "\tlong_name\x18\x02 \x01(\tR\blongName\"A\n" + |
| "\n" + |
| "Expression\x12\x12\n" + |
| "\x04type\x18\x01 \x01(\tR\x04type\x12\x1f\n" + |
| "\vparent_type\x18\x02 \x01(\tR\n" + |
| "parentType\"\xc8\t\n" + |
| "\x03Use\x12=\n" + |
| "\x04type\x18\x01 \x01(\x0e2).net.proto2.go.open2opaque.stats.Use.TypeR\x04type\x12\\\n" + |
| "\x13direct_field_access\x18\x02 \x01(\v2,.net.proto2.go.open2opaque.stats.FieldAccessR\x11directFieldAccess\x12L\n" + |
| "\vmethod_call\x18\x03 \x01(\v2+.net.proto2.go.open2opaque.stats.MethodCallR\n" + |
| "methodCall\x12N\n" + |
| "\vconstructor\x18\x04 \x01(\v2,.net.proto2.go.open2opaque.stats.ConstructorR\vconstructor\x12K\n" + |
| "\n" + |
| "conversion\x18\x05 \x01(\v2+.net.proto2.go.open2opaque.stats.ConversionR\n" + |
| "conversion\x12C\n" + |
| "\bfunc_arg\x18\x06 \x01(\v2(.net.proto2.go.open2opaque.stats.FuncArgR\afuncArg\x12U\n" + |
| "\x0etype_assertion\x18\a \x01(\v2..net.proto2.go.open2opaque.stats.TypeAssertionR\rtypeAssertion\x12X\n" + |
| "\x0ftype_definition\x18\b \x01(\v2/.net.proto2.go.open2opaque.stats.TypeDefinitionR\x0etypeDefinition\x12H\n" + |
| "\tembedding\x18\t \x01(\v2*.net.proto2.go.open2opaque.stats.EmbeddingR\tembedding\x12`\n" + |
| "\x15internal_field_access\x18\n" + |
| " \x01(\v2,.net.proto2.go.open2opaque.stats.FieldAccessR\x13internalFieldAccess\x12O\n" + |
| "\freflect_call\x18\v \x01(\v2,.net.proto2.go.open2opaque.stats.ReflectCallR\vreflectCall\x12O\n" + |
| "\fshallow_copy\x18\f \x01(\v2,.net.proto2.go.open2opaque.stats.ShallowCopyR\vshallowCopy\"\xf4\x01\n" + |
| "\x04Type\x12\x14\n" + |
| "\x10TYPE_UNSPECIFIED\x10\x00\x12\x17\n" + |
| "\x13DIRECT_FIELD_ACCESS\x10\x01\x12\x0f\n" + |
| "\vMETHOD_CALL\x10\x02\x12\x0f\n" + |
| "\vCONSTRUCTOR\x10\x03\x12\x0e\n" + |
| "\n" + |
| "CONVERSION\x10\x04\x12\x12\n" + |
| "\x0eTYPE_ASSERTION\x10\x05\x12\x13\n" + |
| "\x0fTYPE_DEFINITION\x10\x06\x12\r\n" + |
| "\tEMBEDDING\x10\a\x12\x19\n" + |
| "\x15INTERNAL_FIELD_ACCESS\x10\b\x12\x10\n" + |
| "\fREFLECT_CALL\x10\t\x12\x10\n" + |
| "\fSHALLOW_COPY\x10\n" + |
| "\x12\x14\n" + |
| "\x10BUILD_DEPENDENCY\x10\v\"\xc5\x01\n" + |
| "\vReflectCall\x12>\n" + |
| "\x06frames\x18\x01 \x03(\v2&.net.proto2.go.open2opaque.stats.FrameR\x06frames\x126\n" + |
| "\x02fn\x18\x02 \x01(\v2&.net.proto2.go.open2opaque.stats.FrameR\x02fn\x12>\n" + |
| "\x06caller\x18\x03 \x01(\v2&.net.proto2.go.open2opaque.stats.FrameR\x06caller\"\xb9\x01\n" + |
| "\x05Frame\x12\x1a\n" + |
| "\bfunction\x18\x01 \x01(\tR\bfunction\x12\x1f\n" + |
| "\vis_exported\x18\x06 \x01(\bR\n" + |
| "isExported\x12\x18\n" + |
| "\apackage\x18\x02 \x01(\tR\apackage\x12\x12\n" + |
| "\x04file\x18\x03 \x01(\tR\x04file\x12\x12\n" + |
| "\x04line\x18\x04 \x01(\tR\x04line\x12\x14\n" + |
| "\x05index\x18\x05 \x01(\x03R\x05index\x12\x1b\n" + |
| "\tpkg_index\x18\a \x01(\x03R\bpkgIndex\"r\n" + |
| "\vFieldAccess\x12\x1d\n" + |
| "\n" + |
| "field_name\x18\x01 \x01(\tR\tfieldName\x12D\n" + |
| "\n" + |
| "field_type\x18\x02 \x01(\v2%.net.proto2.go.open2opaque.stats.TypeR\tfieldType\"\x9d\x01\n" + |
| "\n" + |
| "MethodCall\x12\x16\n" + |
| "\x06method\x18\x01 \x01(\tR\x06method\x12D\n" + |
| "\x04type\x18\x02 \x01(\x0e20.net.proto2.go.open2opaque.stats.MethodCall.TypeR\x04type\"1\n" + |
| "\x04Type\x12\v\n" + |
| "\aINVALID\x10\x00\x12\r\n" + |
| "\tGET_ONEOF\x10\x01\x12\r\n" + |
| "\tGET_BUILD\x10\x02\"\xa8\x01\n" + |
| "\vConstructor\x12E\n" + |
| "\x04type\x18\x01 \x01(\x0e21.net.proto2.go.open2opaque.stats.Constructor.TypeR\x04type\"R\n" + |
| "\x04Type\x12\x14\n" + |
| "\x10TYPE_UNSPECIFIED\x10\x00\x12\x11\n" + |
| "\rEMPTY_LITERAL\x10\x01\x12\x14\n" + |
| "\x10NONEMPTY_LITERAL\x10\x02\x12\v\n" + |
| "\aBUILDER\x10\x03\"\xea\x02\n" + |
| "\n" + |
| "Conversion\x12$\n" + |
| "\x0edest_type_name\x18\x01 \x01(\tR\fdestTypeName\x12C\n" + |
| "\bfunc_arg\x18\x03 \x01(\v2(.net.proto2.go.open2opaque.stats.FuncArgR\afuncArg\x12M\n" + |
| "\acontext\x18\x02 \x01(\x0e23.net.proto2.go.open2opaque.stats.Conversion.ContextR\acontext\"\xa1\x01\n" + |
| "\aContext\x12\x17\n" + |
| "\x13CONTEXT_UNSPECIFIED\x10\x00\x12\x11\n" + |
| "\rCALL_ARGUMENT\x10\x01\x12\x10\n" + |
| "\fRETURN_VALUE\x10\x02\x12\x0e\n" + |
| "\n" + |
| "ASSIGNMENT\x10\x03\x12\f\n" + |
| "\bEXPLICIT\x10\x04\x12\x1d\n" + |
| "\x19COMPOSITE_LITERAL_ELEMENT\x10\x05\x12\r\n" + |
| "\tCHAN_SEND\x10\x06\x12\f\n" + |
| "\bFUNC_RET\x10\a\"o\n" + |
| "\aFuncArg\x12#\n" + |
| "\rfunction_name\x18\x01 \x01(\tR\ffunctionName\x12!\n" + |
| "\fpackage_path\x18\x02 \x01(\tR\vpackagePath\x12\x1c\n" + |
| "\tsignature\x18\x03 \x01(\tR\tsignature\"Q\n" + |
| "\rTypeAssertion\x12@\n" + |
| "\bsrc_type\x18\x01 \x01(\v2%.net.proto2.go.open2opaque.stats.TypeR\asrcType\"R\n" + |
| "\x0eTypeDefinition\x12@\n" + |
| "\bnew_type\x18\x01 \x01(\v2%.net.proto2.go.open2opaque.stats.TypeR\anewType\",\n" + |
| "\tEmbedding\x12\x1f\n" + |
| "\vfield_index\x18\x01 \x01(\x03R\n" + |
| "fieldIndex\"\x1c\n" + |
| "\x06Source\x12\x12\n" + |
| "\x04file\x18\x01 \x01(\tR\x04file\"\xcd\x01\n" + |
| "\vShallowCopy\x12E\n" + |
| "\x04type\x18\x01 \x01(\x0e21.net.proto2.go.open2opaque.stats.ShallowCopy.TypeR\x04type\"w\n" + |
| "\x04Type\x12\x14\n" + |
| "\x10TYPE_UNSPECIFIED\x10\x00\x12\n" + |
| "\n" + |
| "\x06ASSIGN\x10\x01\x12\x11\n" + |
| "\rCALL_ARGUMENT\x10\x02\x12\f\n" + |
| "\bFUNC_RET\x10\x03\x12\x1d\n" + |
| "\x19COMPOSITE_LITERAL_ELEMENT\x10\x04\x12\r\n" + |
| "\tCHAN_SEND\x10\x05*W\n" + |
| "\fRewriteLevel\x12\x1d\n" + |
| "\x19REWRITE_LEVEL_UNSPECIFIED\x10\x00\x12\b\n" + |
| "\x04NONE\x10\x01\x12\t\n" + |
| "\x05GREEN\x10\x02\x12\n" + |
| "\n" + |
| "\x06YELLOW\x10\x03\x12\a\n" + |
| "\x03RED\x10\x04B\n" + |
| "\x92\x03\a\xd2>\x02\x10\x02\b\x02b\beditionsp\xe8\a" |
| |
| var file_stats_proto_enumTypes = make([]protoimpl.EnumInfo, 7) |
| var file_stats_proto_msgTypes = make([]protoimpl.MessageInfo, 19) |
| var file_stats_proto_goTypes = []any{ |
| (RewriteLevel)(0), // 0: net.proto2.go.open2opaque.stats.RewriteLevel |
| (Status_Type)(0), // 1: net.proto2.go.open2opaque.stats.Status.Type |
| (Use_Type)(0), // 2: net.proto2.go.open2opaque.stats.Use.Type |
| (MethodCall_Type)(0), // 3: net.proto2.go.open2opaque.stats.MethodCall.Type |
| (Constructor_Type)(0), // 4: net.proto2.go.open2opaque.stats.Constructor.Type |
| (Conversion_Context)(0), // 5: net.proto2.go.open2opaque.stats.Conversion.Context |
| (ShallowCopy_Type)(0), // 6: net.proto2.go.open2opaque.stats.ShallowCopy.Type |
| (*Entry)(nil), // 7: net.proto2.go.open2opaque.stats.Entry |
| (*Location)(nil), // 8: net.proto2.go.open2opaque.stats.Location |
| (*Position)(nil), // 9: net.proto2.go.open2opaque.stats.Position |
| (*Status)(nil), // 10: net.proto2.go.open2opaque.stats.Status |
| (*Type)(nil), // 11: net.proto2.go.open2opaque.stats.Type |
| (*Expression)(nil), // 12: net.proto2.go.open2opaque.stats.Expression |
| (*Use)(nil), // 13: net.proto2.go.open2opaque.stats.Use |
| (*ReflectCall)(nil), // 14: net.proto2.go.open2opaque.stats.ReflectCall |
| (*Frame)(nil), // 15: net.proto2.go.open2opaque.stats.Frame |
| (*FieldAccess)(nil), // 16: net.proto2.go.open2opaque.stats.FieldAccess |
| (*MethodCall)(nil), // 17: net.proto2.go.open2opaque.stats.MethodCall |
| (*Constructor)(nil), // 18: net.proto2.go.open2opaque.stats.Constructor |
| (*Conversion)(nil), // 19: net.proto2.go.open2opaque.stats.Conversion |
| (*FuncArg)(nil), // 20: net.proto2.go.open2opaque.stats.FuncArg |
| (*TypeAssertion)(nil), // 21: net.proto2.go.open2opaque.stats.TypeAssertion |
| (*TypeDefinition)(nil), // 22: net.proto2.go.open2opaque.stats.TypeDefinition |
| (*Embedding)(nil), // 23: net.proto2.go.open2opaque.stats.Embedding |
| (*Source)(nil), // 24: net.proto2.go.open2opaque.stats.Source |
| (*ShallowCopy)(nil), // 25: net.proto2.go.open2opaque.stats.ShallowCopy |
| } |
| var file_stats_proto_depIdxs = []int32{ |
| 10, // 0: net.proto2.go.open2opaque.stats.Entry.status:type_name -> net.proto2.go.open2opaque.stats.Status |
| 8, // 1: net.proto2.go.open2opaque.stats.Entry.location:type_name -> net.proto2.go.open2opaque.stats.Location |
| 0, // 2: net.proto2.go.open2opaque.stats.Entry.level:type_name -> net.proto2.go.open2opaque.stats.RewriteLevel |
| 11, // 3: net.proto2.go.open2opaque.stats.Entry.type:type_name -> net.proto2.go.open2opaque.stats.Type |
| 12, // 4: net.proto2.go.open2opaque.stats.Entry.expr:type_name -> net.proto2.go.open2opaque.stats.Expression |
| 13, // 5: net.proto2.go.open2opaque.stats.Entry.use:type_name -> net.proto2.go.open2opaque.stats.Use |
| 24, // 6: net.proto2.go.open2opaque.stats.Entry.source:type_name -> net.proto2.go.open2opaque.stats.Source |
| 9, // 7: net.proto2.go.open2opaque.stats.Location.start:type_name -> net.proto2.go.open2opaque.stats.Position |
| 9, // 8: net.proto2.go.open2opaque.stats.Location.end:type_name -> net.proto2.go.open2opaque.stats.Position |
| 1, // 9: net.proto2.go.open2opaque.stats.Status.type:type_name -> net.proto2.go.open2opaque.stats.Status.Type |
| 2, // 10: net.proto2.go.open2opaque.stats.Use.type:type_name -> net.proto2.go.open2opaque.stats.Use.Type |
| 16, // 11: net.proto2.go.open2opaque.stats.Use.direct_field_access:type_name -> net.proto2.go.open2opaque.stats.FieldAccess |
| 17, // 12: net.proto2.go.open2opaque.stats.Use.method_call:type_name -> net.proto2.go.open2opaque.stats.MethodCall |
| 18, // 13: net.proto2.go.open2opaque.stats.Use.constructor:type_name -> net.proto2.go.open2opaque.stats.Constructor |
| 19, // 14: net.proto2.go.open2opaque.stats.Use.conversion:type_name -> net.proto2.go.open2opaque.stats.Conversion |
| 20, // 15: net.proto2.go.open2opaque.stats.Use.func_arg:type_name -> net.proto2.go.open2opaque.stats.FuncArg |
| 21, // 16: net.proto2.go.open2opaque.stats.Use.type_assertion:type_name -> net.proto2.go.open2opaque.stats.TypeAssertion |
| 22, // 17: net.proto2.go.open2opaque.stats.Use.type_definition:type_name -> net.proto2.go.open2opaque.stats.TypeDefinition |
| 23, // 18: net.proto2.go.open2opaque.stats.Use.embedding:type_name -> net.proto2.go.open2opaque.stats.Embedding |
| 16, // 19: net.proto2.go.open2opaque.stats.Use.internal_field_access:type_name -> net.proto2.go.open2opaque.stats.FieldAccess |
| 14, // 20: net.proto2.go.open2opaque.stats.Use.reflect_call:type_name -> net.proto2.go.open2opaque.stats.ReflectCall |
| 25, // 21: net.proto2.go.open2opaque.stats.Use.shallow_copy:type_name -> net.proto2.go.open2opaque.stats.ShallowCopy |
| 15, // 22: net.proto2.go.open2opaque.stats.ReflectCall.frames:type_name -> net.proto2.go.open2opaque.stats.Frame |
| 15, // 23: net.proto2.go.open2opaque.stats.ReflectCall.fn:type_name -> net.proto2.go.open2opaque.stats.Frame |
| 15, // 24: net.proto2.go.open2opaque.stats.ReflectCall.caller:type_name -> net.proto2.go.open2opaque.stats.Frame |
| 11, // 25: net.proto2.go.open2opaque.stats.FieldAccess.field_type:type_name -> net.proto2.go.open2opaque.stats.Type |
| 3, // 26: net.proto2.go.open2opaque.stats.MethodCall.type:type_name -> net.proto2.go.open2opaque.stats.MethodCall.Type |
| 4, // 27: net.proto2.go.open2opaque.stats.Constructor.type:type_name -> net.proto2.go.open2opaque.stats.Constructor.Type |
| 20, // 28: net.proto2.go.open2opaque.stats.Conversion.func_arg:type_name -> net.proto2.go.open2opaque.stats.FuncArg |
| 5, // 29: net.proto2.go.open2opaque.stats.Conversion.context:type_name -> net.proto2.go.open2opaque.stats.Conversion.Context |
| 11, // 30: net.proto2.go.open2opaque.stats.TypeAssertion.src_type:type_name -> net.proto2.go.open2opaque.stats.Type |
| 11, // 31: net.proto2.go.open2opaque.stats.TypeDefinition.new_type:type_name -> net.proto2.go.open2opaque.stats.Type |
| 6, // 32: net.proto2.go.open2opaque.stats.ShallowCopy.type:type_name -> net.proto2.go.open2opaque.stats.ShallowCopy.Type |
| 33, // [33:33] is the sub-list for method output_type |
| 33, // [33:33] is the sub-list for method input_type |
| 33, // [33:33] is the sub-list for extension type_name |
| 33, // [33:33] is the sub-list for extension extendee |
| 0, // [0:33] is the sub-list for field type_name |
| } |
| |
| func init() { file_stats_proto_init() } |
| func file_stats_proto_init() { |
| if File_stats_proto != nil { |
| return |
| } |
| type x struct{} |
| out := protoimpl.TypeBuilder{ |
| File: protoimpl.DescBuilder{ |
| GoPackagePath: reflect.TypeOf(x{}).PkgPath(), |
| RawDescriptor: unsafe.Slice(unsafe.StringData(file_stats_proto_rawDesc), len(file_stats_proto_rawDesc)), |
| NumEnums: 7, |
| NumMessages: 19, |
| NumExtensions: 0, |
| NumServices: 0, |
| }, |
| GoTypes: file_stats_proto_goTypes, |
| DependencyIndexes: file_stats_proto_depIdxs, |
| EnumInfos: file_stats_proto_enumTypes, |
| MessageInfos: file_stats_proto_msgTypes, |
| }.Build() |
| File_stats_proto = out.File |
| file_stats_proto_goTypes = nil |
| file_stats_proto_depIdxs = nil |
| } |
