diff --git a/garnet/go/src/fidl/compiler/backend/golang/ir/ir.go b/garnet/go/src/fidl/compiler/backend/golang/ir/ir.go
index c6d7ed26af40d495ed409489f0fbc83300e6c0f2..0b892950f5a3f7e831374cd433a951a228905e18 100644
--- a/garnet/go/src/fidl/compiler/backend/golang/ir/ir.go
+++ b/garnet/go/src/fidl/compiler/backend/golang/ir/ir.go
@@ -582,12 +582,6 @@ var handleTypes = map[types.HandleSubtype]string{
types.Vmar: "_zx.VMAR",
}
-func exportIdentifier(name types.EncodedCompoundIdentifier) types.CompoundIdentifier {
- ci := types.ParseCompoundIdentifier(name)
- ci.Name = types.Identifier(common.ToUpperCamelCase(string(ci.Name)))
- return ci
-}
-
func isReservedWord(str string) bool {
_, ok := reservedWords[str]
return ok
@@ -624,8 +618,13 @@ func (_ *compiler) compileIdentifier(id types.Identifier, export bool, ext strin
return changeIfReserved(types.Identifier(str), ext)
}
-func (c *compiler) compileCompoundIdentifier(eci types.EncodedCompoundIdentifier, ext string) string {
- ci := exportIdentifier(eci)
+func (c *compiler) compileCompoundIdentifier(eci types.EncodedCompoundIdentifier, export bool, ext string) string {
+ ci := types.ParseCompoundIdentifier(eci)
+ if export {
+ ci.Name = types.Identifier(common.ToUpperCamelCase(string(ci.Name)))
+ } else {
+ ci.Name = types.Identifier(common.ToLowerCamelCase(string(ci.Name)))
+ }
pkg := compileLibraryIdentifier(ci.Library)
strs := []string{}
if c.inExternalLibrary(ci) {
@@ -707,7 +706,7 @@ func (c *compiler) compileType(val types.Type) (r Type, t Tag, t2 tagNew) {
t2.reverseOfBounds = append(t2.reverseOfBounds, nullability)
r = Type(e)
case types.RequestType:
- e := c.compileCompoundIdentifier(val.RequestSubtype, RequestSuffix)
+ e := c.compileCompoundIdentifier(val.RequestSubtype, true, RequestSuffix)
var nullability int
if val.Nullable {
t.Nullable = true
@@ -733,7 +732,7 @@ func (c *compiler) compileType(val types.Type) (r Type, t Tag, t2 tagNew) {
case types.PrimitiveType:
r = c.compilePrimitiveSubtype(val.PrimitiveSubtype)
case types.IdentifierType:
- e := c.compileCompoundIdentifier(val.Identifier, "")
+ e := c.compileCompoundIdentifier(val.Identifier, true, "")
declType, ok := c.decls[val.Identifier]
if !ok {
log.Fatal("Unknown identifier: ", val.Identifier)
@@ -781,7 +780,7 @@ func (c *compiler) compileBits(val types.Bits) Bits {
t, _, _ := c.compileType(val.Type)
r := Bits{
Attributes: val.Attributes,
- Name: c.compileCompoundIdentifier(val.Name, ""),
+ Name: c.compileCompoundIdentifier(val.Name, true, ""),
Type: t,
}
for _, v := range val.Members {
@@ -796,7 +795,7 @@ func (c *compiler) compileConst(val types.Const) Const {
t, _, _ := c.compileType(val.Type)
return Const{
Attributes: val.Attributes,
- Name: c.compileCompoundIdentifier(val.Name, ""),
+ Name: c.compileCompoundIdentifier(val.Name, true, ""),
Type: t,
Value: c.compileConstant(val.Value),
}
@@ -813,7 +812,7 @@ func (c *compiler) compileEnumMember(val types.EnumMember) EnumMember {
func (c *compiler) compileEnum(val types.Enum) Enum {
r := Enum{
Attributes: val.Attributes,
- Name: c.compileCompoundIdentifier(val.Name, ""),
+ Name: c.compileCompoundIdentifier(val.Name, true, ""),
Type: c.compilePrimitiveSubtype(val.Type),
}
for _, v := range val.Members {
@@ -836,7 +835,7 @@ func (c *compiler) compileStructMember(val types.StructMember) StructMember {
func (c *compiler) compileStruct(val types.Struct) Struct {
r := Struct{
Attributes: val.Attributes,
- Name: c.compileCompoundIdentifier(val.Name, ""),
+ Name: c.compileCompoundIdentifier(val.Name, true, ""),
Size: val.Size,
Alignment: val.Alignment,
}
@@ -862,8 +861,8 @@ func (c *compiler) compileUnionMember(unionName string, val types.UnionMember) U
func (c *compiler) compileUnion(val types.Union) Union {
r := Union{
Attributes: val.Attributes,
- Name: c.compileCompoundIdentifier(val.Name, ""),
- TagName: c.compileCompoundIdentifier(val.Name, TagSuffix),
+ Name: c.compileCompoundIdentifier(val.Name, true, ""),
+ TagName: c.compileCompoundIdentifier(val.Name, true, TagSuffix),
Size: val.Size,
Alignment: val.Alignment,
}
@@ -890,8 +889,8 @@ func (c *compiler) compileXUnion(val types.XUnion) XUnion {
}
return XUnion{
Attributes: val.Attributes,
- Name: c.compileCompoundIdentifier(val.Name, ""),
- TagName: c.compileCompoundIdentifier(val.Name, TagSuffix),
+ Name: c.compileCompoundIdentifier(val.Name, true, ""),
+ TagName: c.compileCompoundIdentifier(val.Name, true, TagSuffix),
Size: val.Size,
Alignment: val.Alignment,
Members: members,
@@ -926,7 +925,7 @@ func (c *compiler) compileTable(val types.Table) Table {
}
return Table{
Attributes: val.Attributes,
- Name: c.compileCompoundIdentifier(val.Name, ""),
+ Name: c.compileCompoundIdentifier(val.Name, true, ""),
Size: val.Size,
Alignment: val.Alignment,
Members: members,
@@ -949,16 +948,16 @@ func (c *compiler) compileMethod(ifaceName types.EncodedCompoundIdentifier, val
Attributes: val.Attributes,
Name: methodName,
Ordinal: val.Ordinal,
- OrdinalName: c.compileCompoundIdentifier(ifaceName, methodName+"Ordinal"),
+ OrdinalName: c.compileCompoundIdentifier(ifaceName, true, methodName+"Ordinal"),
GenOrdinal: val.GenOrdinal,
- GenOrdinalName: c.compileCompoundIdentifier(ifaceName, methodName+"GenOrdinal"),
+ GenOrdinalName: c.compileCompoundIdentifier(ifaceName, true, methodName+"GenOrdinal"),
EventExpectName: "Expect" + methodName,
IsEvent: !val.HasRequest && val.HasResponse,
IsTransitional: val.IsTransitional(),
}
if val.HasRequest {
req := Struct{
- Name: c.compileCompoundIdentifier(ifaceName, methodName+"Request"),
+ Name: c.compileCompoundIdentifier(ifaceName, false, methodName+"Request"),
// We want just the size of the parameter array as a struct, not
// including the message header size.
Size: val.RequestSize - MessageHeaderSize,
@@ -970,7 +969,7 @@ func (c *compiler) compileMethod(ifaceName types.EncodedCompoundIdentifier, val
}
if val.HasResponse {
resp := Struct{
- Name: c.compileCompoundIdentifier(ifaceName, methodName+"Response"),
+ Name: c.compileCompoundIdentifier(ifaceName, false, methodName+"Response"),
// We want just the size of the parameter array as a struct, not
// including the message header size.
Size: val.ResponseSize - MessageHeaderSize,
@@ -990,15 +989,15 @@ func (c *compiler) compileInterface(val types.Interface) Interface {
}
r := Interface{
Attributes: val.Attributes,
- Name: c.compileCompoundIdentifier(val.Name, ""),
- TransitionalBaseName: c.compileCompoundIdentifier(val.Name, TransitionalBaseSuffix),
- ProxyName: c.compileCompoundIdentifier(val.Name, ProxySuffix),
+ Name: c.compileCompoundIdentifier(val.Name, true, ""),
+ TransitionalBaseName: c.compileCompoundIdentifier(val.Name, true, TransitionalBaseSuffix),
+ ProxyName: c.compileCompoundIdentifier(val.Name, true, ProxySuffix),
ProxyType: proxyType,
- StubName: c.compileCompoundIdentifier(val.Name, StubSuffix),
- RequestName: c.compileCompoundIdentifier(val.Name, RequestSuffix),
- EventProxyName: c.compileCompoundIdentifier(val.Name, EventProxySuffix),
- ServerName: c.compileCompoundIdentifier(val.Name, ServiceSuffix),
- ServiceNameConstant: c.compileCompoundIdentifier(val.Name, ServiceNameSuffix),
+ StubName: c.compileCompoundIdentifier(val.Name, true, StubSuffix),
+ RequestName: c.compileCompoundIdentifier(val.Name, true, RequestSuffix),
+ EventProxyName: c.compileCompoundIdentifier(val.Name, true, EventProxySuffix),
+ ServerName: c.compileCompoundIdentifier(val.Name, true, ServiceSuffix),
+ ServiceNameConstant: c.compileCompoundIdentifier(val.Name, true, ServiceNameSuffix),
ServiceNameString: val.GetServiceName(),
}
for _, v := range val.Methods {
diff --git a/garnet/go/src/fidl/compiler/backend/golang/ir/ir_test.go b/garnet/go/src/fidl/compiler/backend/golang/ir/ir_test.go
index 38b5379b0cd320dddfc49be9278660670a00d11a..e574e43e21f4f4e46fcda1370d79ebd13e92646d 100644
--- a/garnet/go/src/fidl/compiler/backend/golang/ir/ir_test.go
+++ b/garnet/go/src/fidl/compiler/backend/golang/ir/ir_test.go
@@ -634,7 +634,7 @@ func TestCompileInterface(t *testing.T) {
GenOrdinalName: "TestFirstGenOrdinal",
Name: "First",
Request: &Struct{
- Name: "TestFirstRequest",
+ Name: "testFirstRequest",
Members: []StructMember{
{
Name: "Value",
@@ -654,7 +654,7 @@ func TestCompileInterface(t *testing.T) {
GenOrdinalName: "TestSecondGenOrdinal",
Name: "Second",
Request: &Struct{
- Name: "TestSecondRequest",
+ Name: "testSecondRequest",
Members: []StructMember{
{
Name: "Value",
@@ -665,7 +665,7 @@ func TestCompileInterface(t *testing.T) {
Size: 16,
},
Response: &Struct{
- Name: "TestSecondResponse",
+ Name: "testSecondResponse",
Members: []StructMember{
{
Name: "Value",
@@ -727,7 +727,7 @@ func TestCompileInterface(t *testing.T) {
GenOrdinalName: "TestFirstGenOrdinal",
Name: "First",
Response: &Struct{
- Name: "TestFirstResponse",
+ Name: "testFirstResponse",
Members: []StructMember{
{
Name: "Value",
diff --git a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json
index 3f246611a79bc74fe5f791d2f34a5ed1713beb27..caa37664e79cfa8ecf2c56fd30c04a1dec3bd89c 100644
--- a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json
+++ b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json
@@ -4,7 +4,49 @@
"library_dependencies": [],
"bits_declarations": [],
"const_declarations": [],
- "enum_declarations": [],
+ "enum_declarations": [
+ {
+ "name": "test.name/ErrorEnun",
+ "location": {
+ "filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
+ "line": 14,
+ "column": 5
+ },
+ "type": "uint32",
+ "members": [
+ {
+ "name": "ERR_FOO",
+ "location": {
+ "filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
+ "line": 15,
+ "column": 4
+ },
+ "value": {
+ "kind": "literal",
+ "literal": {
+ "kind": "numeric",
+ "value": "1"
+ }
+ }
+ },
+ {
+ "name": "ERR_BAR",
+ "location": {
+ "filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
+ "line": 16,
+ "column": 4
+ },
+ "value": {
+ "kind": "literal",
+ "literal": {
+ "kind": "numeric",
+ "value": "2"
+ }
+ }
+ }
+ ]
+ }
+ ],
"interface_declarations": [
{
"name": "test.name/WithAndWithoutRequestResponse",
@@ -256,11 +298,95 @@
}
]
},
+ {
+ "name": "test.name/WithErrorSyntax",
+ "location": {
+ "filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
+ "line": 19,
+ "column": 9
+ },
+ "methods": [
+ {
+ "ordinal": 2069369145,
+ "generated_ordinal": 2069369145,
+ "name": "ErrorAsPrimitive",
+ "location": {
+ "filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
+ "line": 20,
+ "column": 4
+ },
+ "has_request": true,
+ "maybe_request": [],
+ "maybe_request_size": 16,
+ "maybe_request_alignment": 8,
+ "has_response": true,
+ "maybe_response": [
+ {
+ "type": {
+ "kind": "identifier",
+ "identifier": "test.name/WithErrorSyntax_ErrorAsPrimitive_Result",
+ "nullable": false
+ },
+ "name": "result",
+ "location": {
+ "filename": "generated",
+ "line": 18,
+ "column": 0
+ },
+ "size": 8,
+ "max_out_of_line": 0,
+ "alignment": 4,
+ "offset": 16,
+ "max_handles": 0
+ }
+ ],
+ "maybe_response_size": 24,
+ "maybe_response_alignment": 8
+ },
+ {
+ "ordinal": 1284890143,
+ "generated_ordinal": 1284890143,
+ "name": "ErrorAsEnum",
+ "location": {
+ "filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
+ "line": 21,
+ "column": 4
+ },
+ "has_request": true,
+ "maybe_request": [],
+ "maybe_request_size": 16,
+ "maybe_request_alignment": 8,
+ "has_response": true,
+ "maybe_response": [
+ {
+ "type": {
+ "kind": "identifier",
+ "identifier": "test.name/WithErrorSyntax_ErrorAsEnum_Result",
+ "nullable": false
+ },
+ "name": "result",
+ "location": {
+ "filename": "generated",
+ "line": 25,
+ "column": 0
+ },
+ "size": 8,
+ "max_out_of_line": 0,
+ "alignment": 4,
+ "offset": 16,
+ "max_handles": 0
+ }
+ ],
+ "maybe_response_size": 24,
+ "maybe_response_alignment": 8
+ }
+ ]
+ },
{
"name": "test.name/OvernetInternalProtocol",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 15,
+ "line": 25,
"column": 9
},
"maybe_attributes": [
@@ -276,7 +402,7 @@
"name": "MethodA",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 16,
+ "line": 26,
"column": 4
},
"has_request": true,
@@ -289,7 +415,7 @@
"name": "a",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 16,
+ "line": 26,
"column": 18
},
"size": 8,
@@ -306,7 +432,7 @@
"name": "b",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 16,
+ "line": 26,
"column": 27
},
"size": 8,
@@ -326,7 +452,7 @@
"name": "EventA",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 17,
+ "line": 27,
"column": 7
},
"has_request": false,
@@ -340,7 +466,7 @@
"name": "a",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 17,
+ "line": 27,
"column": 20
},
"size": 8,
@@ -357,7 +483,7 @@
"name": "b",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 17,
+ "line": 27,
"column": 29
},
"size": 8,
@@ -376,7 +502,7 @@
"name": "MethodB",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 18,
+ "line": 28,
"column": 4
},
"has_request": true,
@@ -389,7 +515,7 @@
"name": "a",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 18,
+ "line": 28,
"column": 18
},
"size": 8,
@@ -406,7 +532,7 @@
"name": "b",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 18,
+ "line": 28,
"column": 27
},
"size": 8,
@@ -428,7 +554,7 @@
"name": "result",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 18,
+ "line": 28,
"column": 40
},
"size": 8,
@@ -447,7 +573,7 @@
"name": "test.name/SocketControlProtocol",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 22,
+ "line": 32,
"column": 9
},
"maybe_attributes": [
@@ -463,7 +589,7 @@
"name": "MethodA",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 23,
+ "line": 33,
"column": 4
},
"has_request": true,
@@ -476,7 +602,7 @@
"name": "a",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 23,
+ "line": 33,
"column": 18
},
"size": 8,
@@ -493,7 +619,7 @@
"name": "b",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 23,
+ "line": 33,
"column": 27
},
"size": 8,
@@ -513,7 +639,7 @@
"name": "EventA",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 24,
+ "line": 34,
"column": 7
},
"has_request": false,
@@ -527,7 +653,7 @@
"name": "a",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 24,
+ "line": 34,
"column": 20
},
"size": 8,
@@ -544,7 +670,7 @@
"name": "b",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 24,
+ "line": 34,
"column": 29
},
"size": 8,
@@ -563,7 +689,7 @@
"name": "MethodB",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 25,
+ "line": 35,
"column": 4
},
"has_request": true,
@@ -576,7 +702,7 @@
"name": "a",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 25,
+ "line": 35,
"column": 18
},
"size": 8,
@@ -593,7 +719,7 @@
"name": "b",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 25,
+ "line": 35,
"column": 27
},
"size": 8,
@@ -615,7 +741,7 @@
"name": "result",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 25,
+ "line": 35,
"column": 40
},
"size": 8,
@@ -634,7 +760,7 @@
"name": "test.name/ChannelProtocol",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 29,
+ "line": 39,
"column": 9
},
"maybe_attributes": [
@@ -650,7 +776,7 @@
"name": "MethodA",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 30,
+ "line": 40,
"column": 4
},
"has_request": true,
@@ -663,7 +789,7 @@
"name": "a",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 30,
+ "line": 40,
"column": 18
},
"size": 8,
@@ -680,7 +806,7 @@
"name": "b",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 30,
+ "line": 40,
"column": 27
},
"size": 8,
@@ -700,7 +826,7 @@
"name": "EventA",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 31,
+ "line": 41,
"column": 7
},
"has_request": false,
@@ -714,7 +840,7 @@
"name": "a",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 31,
+ "line": 41,
"column": 20
},
"size": 8,
@@ -731,7 +857,7 @@
"name": "b",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 31,
+ "line": 41,
"column": 29
},
"size": 8,
@@ -750,7 +876,7 @@
"name": "MethodB",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 32,
+ "line": 42,
"column": 4
},
"has_request": true,
@@ -763,7 +889,7 @@
"name": "a",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 32,
+ "line": 42,
"column": 18
},
"size": 8,
@@ -780,7 +906,7 @@
"name": "b",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 32,
+ "line": 42,
"column": 27
},
"size": 8,
@@ -802,7 +928,7 @@
"name": "result",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 32,
+ "line": 42,
"column": 40
},
"size": 8,
@@ -821,7 +947,7 @@
"name": "test.name/KitchenSink",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 37,
+ "line": 47,
"column": 9
},
"maybe_attributes": [
@@ -837,7 +963,7 @@
"name": "MethodA",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 38,
+ "line": 48,
"column": 4
},
"has_request": true,
@@ -850,7 +976,7 @@
"name": "a",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 38,
+ "line": 48,
"column": 18
},
"size": 8,
@@ -867,7 +993,7 @@
"name": "b",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 38,
+ "line": 48,
"column": 27
},
"size": 8,
@@ -887,7 +1013,7 @@
"name": "EventA",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 39,
+ "line": 49,
"column": 7
},
"has_request": false,
@@ -901,7 +1027,7 @@
"name": "a",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 39,
+ "line": 49,
"column": 20
},
"size": 8,
@@ -918,7 +1044,7 @@
"name": "b",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 39,
+ "line": 49,
"column": 29
},
"size": 8,
@@ -937,7 +1063,7 @@
"name": "MethodB",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 40,
+ "line": 50,
"column": 4
},
"has_request": true,
@@ -950,7 +1076,7 @@
"name": "a",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 40,
+ "line": 50,
"column": 18
},
"size": 8,
@@ -967,7 +1093,7 @@
"name": "b",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 40,
+ "line": 50,
"column": 27
},
"size": 8,
@@ -989,7 +1115,7 @@
"name": "result",
"location": {
"filename": "garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl",
- "line": 40,
+ "line": 50,
"column": 40
},
"size": 8,
@@ -1005,22 +1131,171 @@
]
}
],
- "struct_declarations": [],
+ "struct_declarations": [
+ {
+ "name": "test.name/WithErrorSyntax_ErrorAsPrimitive_Response",
+ "location": {
+ "filename": "generated",
+ "line": 14,
+ "column": 0
+ },
+ "anonymous": false,
+ "members": [],
+ "size": 1,
+ "max_out_of_line": 0,
+ "alignment": 1,
+ "max_handles": 0
+ },
+ {
+ "name": "test.name/WithErrorSyntax_ErrorAsEnum_Response",
+ "location": {
+ "filename": "generated",
+ "line": 21,
+ "column": 0
+ },
+ "anonymous": false,
+ "members": [],
+ "size": 1,
+ "max_out_of_line": 0,
+ "alignment": 1,
+ "max_handles": 0
+ }
+ ],
"table_declarations": [],
- "union_declarations": [],
+ "union_declarations": [
+ {
+ "name": "test.name/WithErrorSyntax_ErrorAsPrimitive_Result",
+ "location": {
+ "filename": "generated",
+ "line": 17,
+ "column": 0
+ },
+ "maybe_attributes": [
+ {
+ "name": "Result",
+ "value": ""
+ }
+ ],
+ "members": [
+ {
+ "type": {
+ "kind": "identifier",
+ "identifier": "test.name/WithErrorSyntax_ErrorAsPrimitive_Response",
+ "nullable": false
+ },
+ "name": "response",
+ "location": {
+ "filename": "generated",
+ "line": 15,
+ "column": 0
+ },
+ "size": 1,
+ "max_out_of_line": 0,
+ "alignment": 1,
+ "offset": 4
+ },
+ {
+ "type": {
+ "kind": "primitive",
+ "subtype": "uint32"
+ },
+ "name": "err",
+ "location": {
+ "filename": "generated",
+ "line": 16,
+ "column": 0
+ },
+ "size": 4,
+ "max_out_of_line": 0,
+ "alignment": 4,
+ "offset": 4
+ }
+ ],
+ "size": 8,
+ "max_out_of_line": 0,
+ "alignment": 4,
+ "max_handles": 0
+ },
+ {
+ "name": "test.name/WithErrorSyntax_ErrorAsEnum_Result",
+ "location": {
+ "filename": "generated",
+ "line": 24,
+ "column": 0
+ },
+ "maybe_attributes": [
+ {
+ "name": "Result",
+ "value": ""
+ }
+ ],
+ "members": [
+ {
+ "type": {
+ "kind": "identifier",
+ "identifier": "test.name/WithErrorSyntax_ErrorAsEnum_Response",
+ "nullable": false
+ },
+ "name": "response",
+ "location": {
+ "filename": "generated",
+ "line": 22,
+ "column": 0
+ },
+ "size": 1,
+ "max_out_of_line": 0,
+ "alignment": 1,
+ "offset": 4
+ },
+ {
+ "type": {
+ "kind": "identifier",
+ "identifier": "test.name/ErrorEnun",
+ "nullable": false
+ },
+ "name": "err",
+ "location": {
+ "filename": "generated",
+ "line": 23,
+ "column": 0
+ },
+ "size": 4,
+ "max_out_of_line": 0,
+ "alignment": 4,
+ "offset": 4
+ }
+ ],
+ "size": 8,
+ "max_out_of_line": 0,
+ "alignment": 4,
+ "max_handles": 0
+ }
+ ],
"xunion_declarations": [],
"declaration_order": [
+ "test.name/WithErrorSyntax_ErrorAsPrimitive_Response",
+ "test.name/WithErrorSyntax_ErrorAsPrimitive_Result",
+ "test.name/WithErrorSyntax_ErrorAsEnum_Response",
"test.name/KitchenSink",
"test.name/ChannelProtocol",
"test.name/SocketControlProtocol",
"test.name/OvernetInternalProtocol",
- "test.name/WithAndWithoutRequestResponse"
+ "test.name/WithAndWithoutRequestResponse",
+ "test.name/ErrorEnun",
+ "test.name/WithErrorSyntax_ErrorAsEnum_Result",
+ "test.name/WithErrorSyntax"
],
"declarations": {
+ "test.name/ErrorEnun": "enum",
"test.name/WithAndWithoutRequestResponse": "interface",
+ "test.name/WithErrorSyntax": "interface",
"test.name/OvernetInternalProtocol": "interface",
"test.name/SocketControlProtocol": "interface",
"test.name/ChannelProtocol": "interface",
- "test.name/KitchenSink": "interface"
+ "test.name/KitchenSink": "interface",
+ "test.name/WithErrorSyntax_ErrorAsPrimitive_Response": "struct",
+ "test.name/WithErrorSyntax_ErrorAsEnum_Response": "struct",
+ "test.name/WithErrorSyntax_ErrorAsPrimitive_Result": "union",
+ "test.name/WithErrorSyntax_ErrorAsEnum_Result": "union"
}
}
diff --git a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.cc.golden b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.cc.golden
index 7a1b319cac297f73987c480a30daaabe274c7bc1..e19bbcc9d28306255945b97a462c0a68a502a208 100644
--- a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.cc.golden
+++ b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.cc.golden
@@ -6,6 +6,158 @@
namespace test {
namespace name {
+extern "C" const fidl_type_t test_name_WithErrorSyntax_ErrorAsPrimitive_ResponseTable;
+const fidl_type_t* WithErrorSyntax_ErrorAsPrimitive_Response::FidlType = &test_name_WithErrorSyntax_ErrorAsPrimitive_ResponseTable;
+
+void WithErrorSyntax_ErrorAsPrimitive_Response::Encode(::fidl::Encoder* _encoder, size_t _offset) {
+ ::fidl::Encode(_encoder, &__reserved, _offset + 0);
+}
+
+void WithErrorSyntax_ErrorAsPrimitive_Response::Decode(::fidl::Decoder* _decoder, WithErrorSyntax_ErrorAsPrimitive_Response* value, size_t _offset) {
+ ::fidl::Decode(_decoder, &value->__reserved, _offset + 0);
+}
+
+zx_status_t WithErrorSyntax_ErrorAsPrimitive_Response::Clone(WithErrorSyntax_ErrorAsPrimitive_Response* _result) const {
+ zx_status_t _status = ::fidl::Clone(__reserved, &_result->__reserved);
+ if (_status != ZX_OK)
+ return _status;
+ return ZX_OK;
+}
+
+bool operator==(const WithErrorSyntax_ErrorAsPrimitive_Response& _lhs, const WithErrorSyntax_ErrorAsPrimitive_Response& _rhs) {
+ if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) {
+ return false;
+ }
+ return true;
+}
+WithErrorSyntax_ErrorAsPrimitive_Result::WithErrorSyntax_ErrorAsPrimitive_Result() : value_() {}
+
+WithErrorSyntax_ErrorAsPrimitive_Result::~WithErrorSyntax_ErrorAsPrimitive_Result() {
+}
+
+WithErrorSyntax_ErrorAsPrimitive_Result::WithErrorSyntax_ErrorAsPrimitive_Result(WithErrorSyntax_ErrorAsPrimitive_Result&& other) : value_(std::move(other.value_)) {
+}
+
+WithErrorSyntax_ErrorAsPrimitive_Result& WithErrorSyntax_ErrorAsPrimitive_Result::operator=(WithErrorSyntax_ErrorAsPrimitive_Result&& other) {
+ if (this != &other) {
+ value_ = std::move(other.value_);
+ }
+ return *this;
+}
+
+void WithErrorSyntax_ErrorAsPrimitive_Result::Encode(::fidl::Encoder* _encoder, size_t _offset) {
+ fidl_union_tag_t _tag = static_cast<fidl_union_tag_t>(Which());
+ ::fidl::Encode(_encoder, &_tag, _offset);
+ switch (_tag) {
+ case 0:
+ ::fidl::Encode(_encoder, &response(), _offset + 4);
+ break;
+ case 1:
+ ::fidl::Encode(_encoder, &err(), _offset + 4);
+ break;
+ default:
+ break;
+ }
+}
+
+void WithErrorSyntax_ErrorAsPrimitive_Result::Decode(::fidl::Decoder* _decoder, WithErrorSyntax_ErrorAsPrimitive_Result* _value, size_t _offset) {
+ fidl_union_tag_t _tag;
+ ::fidl::Decode(_decoder, &_tag, _offset);
+ switch (_tag) {
+ case 0:
+ {
+ WithErrorSyntax_ErrorAsPrimitive_Response _member{};
+ ::fidl::Decode(_decoder, &_member, _offset + 4);
+ _value->set_response(std::move(_member));
+ break;
+ }
+ case 1:
+ {
+ uint32_t _member{};
+ ::fidl::Decode(_decoder, &_member, _offset + 4);
+ _value->set_err(std::move(_member));
+ break;
+ }
+ default:
+ _value->value_.emplace<0>();
+ }
+}
+
+zx_status_t WithErrorSyntax_ErrorAsPrimitive_Result::Clone(WithErrorSyntax_ErrorAsPrimitive_Result* _result) const {
+ zx_status_t _status = ZX_OK;
+ switch (Which()) {
+ case Tag::kResponse:
+ {
+ WithErrorSyntax_ErrorAsPrimitive_Response _member{};
+ _status = ::fidl::Clone(response(), &_member);
+ if (_status == ZX_OK) {
+ _result->set_response(std::move(_member));
+ }
+ }
+ break;
+ case Tag::kErr:
+ {
+ uint32_t _member{};
+ _status = ::fidl::Clone(err(), &_member);
+ if (_status == ZX_OK) {
+ _result->set_err(std::move(_member));
+ }
+ }
+ break;
+ case Tag::Invalid:
+ _result->value_.emplace<0>();
+ break;
+ }
+ return _status;
+}
+
+bool operator==(const WithErrorSyntax_ErrorAsPrimitive_Result& _lhs, const WithErrorSyntax_ErrorAsPrimitive_Result& _rhs) {
+ if (_lhs.Which() != _rhs.Which()) {
+ return false;
+ }
+ switch (_lhs.Which()) {
+ case WithErrorSyntax_ErrorAsPrimitive_Result::Tag::kResponse:
+ return ::fidl::Equals(_lhs.response(), _rhs.response());
+ case WithErrorSyntax_ErrorAsPrimitive_Result::Tag::kErr:
+ return ::fidl::Equals(_lhs.err(), _rhs.err());
+ case WithErrorSyntax_ErrorAsPrimitive_Result::Tag::Invalid:
+ return true;
+ default:
+ return false;
+ }
+}
+
+void WithErrorSyntax_ErrorAsPrimitive_Result::set_response(WithErrorSyntax_ErrorAsPrimitive_Response value) {
+ value_.emplace<static_cast<size_t>(Tag::kResponse) + 1>(std::move(value));
+}
+
+void WithErrorSyntax_ErrorAsPrimitive_Result::set_err(uint32_t value) {
+ value_.emplace<static_cast<size_t>(Tag::kErr) + 1>(std::move(value));
+}
+extern "C" const fidl_type_t test_name_WithErrorSyntax_ErrorAsEnum_ResponseTable;
+const fidl_type_t* WithErrorSyntax_ErrorAsEnum_Response::FidlType = &test_name_WithErrorSyntax_ErrorAsEnum_ResponseTable;
+
+void WithErrorSyntax_ErrorAsEnum_Response::Encode(::fidl::Encoder* _encoder, size_t _offset) {
+ ::fidl::Encode(_encoder, &__reserved, _offset + 0);
+}
+
+void WithErrorSyntax_ErrorAsEnum_Response::Decode(::fidl::Decoder* _decoder, WithErrorSyntax_ErrorAsEnum_Response* value, size_t _offset) {
+ ::fidl::Decode(_decoder, &value->__reserved, _offset + 0);
+}
+
+zx_status_t WithErrorSyntax_ErrorAsEnum_Response::Clone(WithErrorSyntax_ErrorAsEnum_Response* _result) const {
+ zx_status_t _status = ::fidl::Clone(__reserved, &_result->__reserved);
+ if (_status != ZX_OK)
+ return _status;
+ return ZX_OK;
+}
+
+bool operator==(const WithErrorSyntax_ErrorAsEnum_Response& _lhs, const WithErrorSyntax_ErrorAsEnum_Response& _rhs) {
+ if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) {
+ return false;
+ }
+ return true;
+}
#ifdef __Fuchsia__
namespace {
@@ -1290,5 +1442,325 @@ zx_status_t WithAndWithoutRequestResponse_SyncProxy::WithRequestWithResponse(::s
#endif // __Fuchsia__
+WithErrorSyntax_ErrorAsEnum_Result::WithErrorSyntax_ErrorAsEnum_Result() : value_() {}
+
+WithErrorSyntax_ErrorAsEnum_Result::~WithErrorSyntax_ErrorAsEnum_Result() {
+}
+
+WithErrorSyntax_ErrorAsEnum_Result::WithErrorSyntax_ErrorAsEnum_Result(WithErrorSyntax_ErrorAsEnum_Result&& other) : value_(std::move(other.value_)) {
+}
+
+WithErrorSyntax_ErrorAsEnum_Result& WithErrorSyntax_ErrorAsEnum_Result::operator=(WithErrorSyntax_ErrorAsEnum_Result&& other) {
+ if (this != &other) {
+ value_ = std::move(other.value_);
+ }
+ return *this;
+}
+
+void WithErrorSyntax_ErrorAsEnum_Result::Encode(::fidl::Encoder* _encoder, size_t _offset) {
+ fidl_union_tag_t _tag = static_cast<fidl_union_tag_t>(Which());
+ ::fidl::Encode(_encoder, &_tag, _offset);
+ switch (_tag) {
+ case 0:
+ ::fidl::Encode(_encoder, &response(), _offset + 4);
+ break;
+ case 1:
+ ::fidl::Encode(_encoder, &err(), _offset + 4);
+ break;
+ default:
+ break;
+ }
+}
+
+void WithErrorSyntax_ErrorAsEnum_Result::Decode(::fidl::Decoder* _decoder, WithErrorSyntax_ErrorAsEnum_Result* _value, size_t _offset) {
+ fidl_union_tag_t _tag;
+ ::fidl::Decode(_decoder, &_tag, _offset);
+ switch (_tag) {
+ case 0:
+ {
+ WithErrorSyntax_ErrorAsEnum_Response _member{};
+ ::fidl::Decode(_decoder, &_member, _offset + 4);
+ _value->set_response(std::move(_member));
+ break;
+ }
+ case 1:
+ {
+ ErrorEnun _member{};
+ ::fidl::Decode(_decoder, &_member, _offset + 4);
+ _value->set_err(std::move(_member));
+ break;
+ }
+ default:
+ _value->value_.emplace<0>();
+ }
+}
+
+zx_status_t WithErrorSyntax_ErrorAsEnum_Result::Clone(WithErrorSyntax_ErrorAsEnum_Result* _result) const {
+ zx_status_t _status = ZX_OK;
+ switch (Which()) {
+ case Tag::kResponse:
+ {
+ WithErrorSyntax_ErrorAsEnum_Response _member{};
+ _status = ::fidl::Clone(response(), &_member);
+ if (_status == ZX_OK) {
+ _result->set_response(std::move(_member));
+ }
+ }
+ break;
+ case Tag::kErr:
+ {
+ ErrorEnun _member{};
+ _status = ::fidl::Clone(err(), &_member);
+ if (_status == ZX_OK) {
+ _result->set_err(std::move(_member));
+ }
+ }
+ break;
+ case Tag::Invalid:
+ _result->value_.emplace<0>();
+ break;
+ }
+ return _status;
+}
+
+bool operator==(const WithErrorSyntax_ErrorAsEnum_Result& _lhs, const WithErrorSyntax_ErrorAsEnum_Result& _rhs) {
+ if (_lhs.Which() != _rhs.Which()) {
+ return false;
+ }
+ switch (_lhs.Which()) {
+ case WithErrorSyntax_ErrorAsEnum_Result::Tag::kResponse:
+ return ::fidl::Equals(_lhs.response(), _rhs.response());
+ case WithErrorSyntax_ErrorAsEnum_Result::Tag::kErr:
+ return ::fidl::Equals(_lhs.err(), _rhs.err());
+ case WithErrorSyntax_ErrorAsEnum_Result::Tag::Invalid:
+ return true;
+ default:
+ return false;
+ }
+}
+
+void WithErrorSyntax_ErrorAsEnum_Result::set_response(WithErrorSyntax_ErrorAsEnum_Response value) {
+ value_.emplace<static_cast<size_t>(Tag::kResponse) + 1>(std::move(value));
+}
+
+void WithErrorSyntax_ErrorAsEnum_Result::set_err(ErrorEnun value) {
+ value_.emplace<static_cast<size_t>(Tag::kErr) + 1>(std::move(value));
+}
+#ifdef __Fuchsia__
+namespace {
+
+constexpr uint32_t kWithErrorSyntax_ErrorAsPrimitive_Ordinal = 2069369145u;
+extern "C" const fidl_type_t test_name_WithErrorSyntaxErrorAsPrimitiveRequestTable;
+extern "C" const fidl_type_t test_name_WithErrorSyntaxErrorAsPrimitiveResponseTable;
+
+constexpr uint32_t kWithErrorSyntax_ErrorAsEnum_Ordinal = 1284890143u;
+extern "C" const fidl_type_t test_name_WithErrorSyntaxErrorAsEnumRequestTable;
+extern "C" const fidl_type_t test_name_WithErrorSyntaxErrorAsEnumResponseTable;
+
+} // namespace
+
+WithErrorSyntax::~WithErrorSyntax() = default;
+
+WithErrorSyntax_EventSender::~WithErrorSyntax_EventSender() = default;
+
+WithErrorSyntax_Sync::~WithErrorSyntax_Sync() = default;
+
+WithErrorSyntax_Proxy::WithErrorSyntax_Proxy(::fidl::internal::ProxyController* controller)
+ : controller_(controller) {
+ (void)controller_;
+}
+
+WithErrorSyntax_Proxy::~WithErrorSyntax_Proxy() = default;
+
+zx_status_t WithErrorSyntax_Proxy::Dispatch_(::fidl::Message message) {
+ zx_status_t status = ZX_OK;
+ switch (message.ordinal()) {
+ default: {
+ status = ZX_ERR_NOT_SUPPORTED;
+ break;
+ }
+ }
+ return status;
+}
+
+
+namespace {
+
+class WithErrorSyntax_ErrorAsPrimitive_ResponseHandler : public ::fidl::internal::MessageHandler {
+ public:
+ WithErrorSyntax_ErrorAsPrimitive_ResponseHandler(WithErrorSyntax::ErrorAsPrimitiveCallback callback)
+ : callback_(std::move(callback)) {
+ ZX_DEBUG_ASSERT_MSG(callback_,
+ "Callback must not be empty for WithErrorSyntax::ErrorAsPrimitive\n");
+ }
+
+ zx_status_t OnMessage(::fidl::Message message) override {
+ const char* error_msg = nullptr;
+ zx_status_t status = message.Decode(&test_name_WithErrorSyntaxErrorAsPrimitiveResponseTable, &error_msg);
+ if (status != ZX_OK) {
+ FIDL_REPORT_DECODING_ERROR(message, &test_name_WithErrorSyntaxErrorAsPrimitiveResponseTable, error_msg);
+ return status;
+ }
+ ::fidl::Decoder decoder(std::move(message));
+ auto arg0 = ::fidl::DecodeAs<WithErrorSyntax_ErrorAsPrimitive_Result>(&decoder, 16);
+ callback_(std::move(arg0));
+ return ZX_OK;
+ }
+
+ private:
+ WithErrorSyntax::ErrorAsPrimitiveCallback callback_;
+
+ WithErrorSyntax_ErrorAsPrimitive_ResponseHandler(const WithErrorSyntax_ErrorAsPrimitive_ResponseHandler&) = delete;
+ WithErrorSyntax_ErrorAsPrimitive_ResponseHandler& operator=(const WithErrorSyntax_ErrorAsPrimitive_ResponseHandler&) = delete;
+};
+
+} // namespace
+void WithErrorSyntax_Proxy::ErrorAsPrimitive(ErrorAsPrimitiveCallback callback) {
+ ::fidl::Encoder _encoder(kWithErrorSyntax_ErrorAsPrimitive_Ordinal);
+ controller_->Send(&test_name_WithErrorSyntaxErrorAsPrimitiveRequestTable, _encoder.GetMessage(), std::make_unique<WithErrorSyntax_ErrorAsPrimitive_ResponseHandler>(std::move(callback)));
+}
+namespace {
+
+class WithErrorSyntax_ErrorAsEnum_ResponseHandler : public ::fidl::internal::MessageHandler {
+ public:
+ WithErrorSyntax_ErrorAsEnum_ResponseHandler(WithErrorSyntax::ErrorAsEnumCallback callback)
+ : callback_(std::move(callback)) {
+ ZX_DEBUG_ASSERT_MSG(callback_,
+ "Callback must not be empty for WithErrorSyntax::ErrorAsEnum\n");
+ }
+
+ zx_status_t OnMessage(::fidl::Message message) override {
+ const char* error_msg = nullptr;
+ zx_status_t status = message.Decode(&test_name_WithErrorSyntaxErrorAsEnumResponseTable, &error_msg);
+ if (status != ZX_OK) {
+ FIDL_REPORT_DECODING_ERROR(message, &test_name_WithErrorSyntaxErrorAsEnumResponseTable, error_msg);
+ return status;
+ }
+ ::fidl::Decoder decoder(std::move(message));
+ auto arg0 = ::fidl::DecodeAs<WithErrorSyntax_ErrorAsEnum_Result>(&decoder, 16);
+ callback_(std::move(arg0));
+ return ZX_OK;
+ }
+
+ private:
+ WithErrorSyntax::ErrorAsEnumCallback callback_;
+
+ WithErrorSyntax_ErrorAsEnum_ResponseHandler(const WithErrorSyntax_ErrorAsEnum_ResponseHandler&) = delete;
+ WithErrorSyntax_ErrorAsEnum_ResponseHandler& operator=(const WithErrorSyntax_ErrorAsEnum_ResponseHandler&) = delete;
+};
+
+} // namespace
+void WithErrorSyntax_Proxy::ErrorAsEnum(ErrorAsEnumCallback callback) {
+ ::fidl::Encoder _encoder(kWithErrorSyntax_ErrorAsEnum_Ordinal);
+ controller_->Send(&test_name_WithErrorSyntaxErrorAsEnumRequestTable, _encoder.GetMessage(), std::make_unique<WithErrorSyntax_ErrorAsEnum_ResponseHandler>(std::move(callback)));
+}
+
+WithErrorSyntax_Stub::WithErrorSyntax_Stub(WithErrorSyntax_clazz* impl) : impl_(impl) {
+ (void)impl_;
+}
+
+WithErrorSyntax_Stub::~WithErrorSyntax_Stub() = default;
+
+namespace {
+
+class WithErrorSyntax_ErrorAsPrimitive_Responder {
+ public:
+ WithErrorSyntax_ErrorAsPrimitive_Responder(::fidl::internal::PendingResponse response, uint32_t ordinal)
+ : response_(std::move(response)), ordinal_(ordinal) {}
+
+ void operator()(WithErrorSyntax_ErrorAsPrimitive_Result result) {
+ ::fidl::Encoder _encoder(ordinal_);
+ _encoder.Alloc(24 - sizeof(fidl_message_header_t));
+ ::fidl::Encode(&_encoder, &result, 16);
+ response_.Send(&test_name_WithErrorSyntaxErrorAsPrimitiveResponseTable, _encoder.GetMessage());
+ }
+
+ private:
+ ::fidl::internal::PendingResponse response_;
+ uint32_t ordinal_;
+};
+
+class WithErrorSyntax_ErrorAsEnum_Responder {
+ public:
+ WithErrorSyntax_ErrorAsEnum_Responder(::fidl::internal::PendingResponse response, uint32_t ordinal)
+ : response_(std::move(response)), ordinal_(ordinal) {}
+
+ void operator()(WithErrorSyntax_ErrorAsEnum_Result result) {
+ ::fidl::Encoder _encoder(ordinal_);
+ _encoder.Alloc(24 - sizeof(fidl_message_header_t));
+ ::fidl::Encode(&_encoder, &result, 16);
+ response_.Send(&test_name_WithErrorSyntaxErrorAsEnumResponseTable, _encoder.GetMessage());
+ }
+
+ private:
+ ::fidl::internal::PendingResponse response_;
+ uint32_t ordinal_;
+};
+
+} // namespace
+
+zx_status_t WithErrorSyntax_Stub::Dispatch_(
+ ::fidl::Message message,
+ ::fidl::internal::PendingResponse response) {
+ zx_status_t status = ZX_OK;
+ uint32_t ordinal = message.ordinal();
+ switch (ordinal) {
+ case kWithErrorSyntax_ErrorAsPrimitive_Ordinal: {
+ const char* error_msg = nullptr;
+ status = message.Decode(&test_name_WithErrorSyntaxErrorAsPrimitiveRequestTable, &error_msg);
+ if (status != ZX_OK) {
+ FIDL_REPORT_DECODING_ERROR(message, &test_name_WithErrorSyntaxErrorAsPrimitiveRequestTable, error_msg);
+ break;
+ }
+ impl_->ErrorAsPrimitive(WithErrorSyntax_ErrorAsPrimitive_Responder(std::move(response), ordinal));
+ break;
+ }
+ case kWithErrorSyntax_ErrorAsEnum_Ordinal: {
+ const char* error_msg = nullptr;
+ status = message.Decode(&test_name_WithErrorSyntaxErrorAsEnumRequestTable, &error_msg);
+ if (status != ZX_OK) {
+ FIDL_REPORT_DECODING_ERROR(message, &test_name_WithErrorSyntaxErrorAsEnumRequestTable, error_msg);
+ break;
+ }
+ impl_->ErrorAsEnum(WithErrorSyntax_ErrorAsEnum_Responder(std::move(response), ordinal));
+ break;
+ }
+ default: {
+ status = ZX_ERR_NOT_SUPPORTED;
+ break;
+ }
+ }
+ return status;
+}
+
+WithErrorSyntax_SyncProxy::WithErrorSyntax_SyncProxy(::zx::channel channel)
+ : proxy_(::std::move(channel)) {}
+
+WithErrorSyntax_SyncProxy::~WithErrorSyntax_SyncProxy() = default;
+zx_status_t WithErrorSyntax_SyncProxy::ErrorAsPrimitive(WithErrorSyntax_ErrorAsPrimitive_Result* out_result) {
+ ::fidl::Encoder _encoder(kWithErrorSyntax_ErrorAsPrimitive_Ordinal);
+ ::fidl::MessageBuffer buffer_;
+ ::fidl::Message response_ = buffer_.CreateEmptyMessage();
+ zx_status_t status_ = proxy_.Call(&test_name_WithErrorSyntaxErrorAsPrimitiveRequestTable, &test_name_WithErrorSyntaxErrorAsPrimitiveResponseTable, _encoder.GetMessage(), &response_);
+ if (status_ != ZX_OK)
+ return status_;
+ ::fidl::Decoder decoder_(std::move(response_));
+ *out_result = ::fidl::DecodeAs<WithErrorSyntax_ErrorAsPrimitive_Result>(&decoder_, 16);
+ return ZX_OK;
+}
+zx_status_t WithErrorSyntax_SyncProxy::ErrorAsEnum(WithErrorSyntax_ErrorAsEnum_Result* out_result) {
+ ::fidl::Encoder _encoder(kWithErrorSyntax_ErrorAsEnum_Ordinal);
+ ::fidl::MessageBuffer buffer_;
+ ::fidl::Message response_ = buffer_.CreateEmptyMessage();
+ zx_status_t status_ = proxy_.Call(&test_name_WithErrorSyntaxErrorAsEnumRequestTable, &test_name_WithErrorSyntaxErrorAsEnumResponseTable, _encoder.GetMessage(), &response_);
+ if (status_ != ZX_OK)
+ return status_;
+ ::fidl::Decoder decoder_(std::move(response_));
+ *out_result = ::fidl::DecodeAs<WithErrorSyntax_ErrorAsEnum_Result>(&decoder_, 16);
+ return ZX_OK;
+}
+
+#endif // __Fuchsia__
+
} // namespace name
} // namespace test
diff --git a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.go.golden b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.go.golden
index 3b36bfb3cf128e025a6f03055f360b76e2d034e2..90ca9170627eca3d22ea0093a5674c994c975d8c 100644
--- a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.go.golden
+++ b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.go.golden
@@ -11,6 +11,135 @@ import (
+
+type ErrorEnun uint32
+const (
+ ErrorEnunErrFoo ErrorEnun = 1
+ ErrorEnunErrBar ErrorEnun = 2
+)
+func (x ErrorEnun) String() string {
+ switch x {
+ case 1:
+ return "ErrFoo"
+ case 2:
+ return "ErrBar"
+ }
+ return "Unknown"
+}
+
+type WithErrorSyntaxErrorAsPrimitiveResponse struct {
+ _ struct{} `fidl2:"s,1,1"`
+}
+
+var _mWithErrorSyntaxErrorAsPrimitiveResponse = _bindings.CreateLazyMarshaler(WithErrorSyntaxErrorAsPrimitiveResponse{})
+
+func (msg *WithErrorSyntaxErrorAsPrimitiveResponse) Marshaler() _bindings.Marshaler {
+ return _mWithErrorSyntaxErrorAsPrimitiveResponse
+}
+
+// Implements Payload.
+func (_ *WithErrorSyntaxErrorAsPrimitiveResponse) InlineAlignment() int {
+ return 1
+}
+
+// Implements Payload.
+func (_ *WithErrorSyntaxErrorAsPrimitiveResponse) InlineSize() int {
+ return 1
+}
+
+type WithErrorSyntaxErrorAsEnumResponse struct {
+ _ struct{} `fidl2:"s,1,1"`
+}
+
+var _mWithErrorSyntaxErrorAsEnumResponse = _bindings.CreateLazyMarshaler(WithErrorSyntaxErrorAsEnumResponse{})
+
+func (msg *WithErrorSyntaxErrorAsEnumResponse) Marshaler() _bindings.Marshaler {
+ return _mWithErrorSyntaxErrorAsEnumResponse
+}
+
+// Implements Payload.
+func (_ *WithErrorSyntaxErrorAsEnumResponse) InlineAlignment() int {
+ return 1
+}
+
+// Implements Payload.
+func (_ *WithErrorSyntaxErrorAsEnumResponse) InlineSize() int {
+ return 1
+}
+type WithErrorSyntaxErrorAsPrimitiveResultTag uint32
+const (
+ _ WithErrorSyntaxErrorAsPrimitiveResultTag = iota
+ WithErrorSyntaxErrorAsPrimitiveResultResponse
+ WithErrorSyntaxErrorAsPrimitiveResultErr
+)
+
+
+type WithErrorSyntaxErrorAsPrimitiveResult struct {
+ WithErrorSyntaxErrorAsPrimitiveResultTag `fidl:"tag" fidl2:"u,8,4"`
+ Response WithErrorSyntaxErrorAsPrimitiveResponse
+ Err uint32
+}
+
+// Implements Payload.
+func (_ *WithErrorSyntaxErrorAsPrimitiveResult) InlineAlignment() int {
+ return 4
+}
+
+// Implements Payload.
+func (_ *WithErrorSyntaxErrorAsPrimitiveResult) InlineSize() int {
+ return 8
+}
+
+func (u *WithErrorSyntaxErrorAsPrimitiveResult) Which() WithErrorSyntaxErrorAsPrimitiveResultTag {
+ return u.WithErrorSyntaxErrorAsPrimitiveResultTag
+}
+
+func (u *WithErrorSyntaxErrorAsPrimitiveResult) SetResponse(response WithErrorSyntaxErrorAsPrimitiveResponse) {
+ u.WithErrorSyntaxErrorAsPrimitiveResultTag = WithErrorSyntaxErrorAsPrimitiveResultResponse
+ u.Response = response
+}
+
+func (u *WithErrorSyntaxErrorAsPrimitiveResult) SetErr(err uint32) {
+ u.WithErrorSyntaxErrorAsPrimitiveResultTag = WithErrorSyntaxErrorAsPrimitiveResultErr
+ u.Err = err
+}
+type WithErrorSyntaxErrorAsEnumResultTag uint32
+const (
+ _ WithErrorSyntaxErrorAsEnumResultTag = iota
+ WithErrorSyntaxErrorAsEnumResultResponse
+ WithErrorSyntaxErrorAsEnumResultErr
+)
+
+
+type WithErrorSyntaxErrorAsEnumResult struct {
+ WithErrorSyntaxErrorAsEnumResultTag `fidl:"tag" fidl2:"u,8,4"`
+ Response WithErrorSyntaxErrorAsEnumResponse
+ Err ErrorEnun
+}
+
+// Implements Payload.
+func (_ *WithErrorSyntaxErrorAsEnumResult) InlineAlignment() int {
+ return 4
+}
+
+// Implements Payload.
+func (_ *WithErrorSyntaxErrorAsEnumResult) InlineSize() int {
+ return 8
+}
+
+func (u *WithErrorSyntaxErrorAsEnumResult) Which() WithErrorSyntaxErrorAsEnumResultTag {
+ return u.WithErrorSyntaxErrorAsEnumResultTag
+}
+
+func (u *WithErrorSyntaxErrorAsEnumResult) SetResponse(response WithErrorSyntaxErrorAsEnumResponse) {
+ u.WithErrorSyntaxErrorAsEnumResultTag = WithErrorSyntaxErrorAsEnumResultResponse
+ u.Response = response
+}
+
+func (u *WithErrorSyntaxErrorAsEnumResult) SetErr(err ErrorEnun) {
+ u.WithErrorSyntaxErrorAsEnumResultTag = WithErrorSyntaxErrorAsEnumResultErr
+ u.Err = err
+}
const (
WithAndWithoutRequestResponseNoRequestNoResponseOrdinal uint32 = 503576693
WithAndWithoutRequestResponseNoRequestNoResponseGenOrdinal uint32 = 503576693
@@ -30,129 +159,129 @@ const (
WithAndWithoutRequestResponseOnWithResponseGenOrdinal uint32 = 2051478023
)
-type WithAndWithoutRequestResponseNoRequestWithResponseResponse struct {
+type withAndWithoutRequestResponseNoRequestWithResponseResponse struct {
_ struct{} `fidl2:"s,16,0"`
Ret string
}
-var _mWithAndWithoutRequestResponseNoRequestWithResponseResponse = _bindings.CreateLazyMarshaler(WithAndWithoutRequestResponseNoRequestWithResponseResponse{})
+var _mwithAndWithoutRequestResponseNoRequestWithResponseResponse = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseNoRequestWithResponseResponse{})
-func (msg *WithAndWithoutRequestResponseNoRequestWithResponseResponse) Marshaler() _bindings.Marshaler {
- return _mWithAndWithoutRequestResponseNoRequestWithResponseResponse
+func (msg *withAndWithoutRequestResponseNoRequestWithResponseResponse) Marshaler() _bindings.Marshaler {
+ return _mwithAndWithoutRequestResponseNoRequestWithResponseResponse
}
// Implements Payload.
-func (_ *WithAndWithoutRequestResponseNoRequestWithResponseResponse) InlineAlignment() int {
+func (_ *withAndWithoutRequestResponseNoRequestWithResponseResponse) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *WithAndWithoutRequestResponseNoRequestWithResponseResponse) InlineSize() int {
+func (_ *withAndWithoutRequestResponseNoRequestWithResponseResponse) InlineSize() int {
return 16
}
-type WithAndWithoutRequestResponseWithRequestNoResponseRequest struct {
+type withAndWithoutRequestResponseWithRequestNoResponseRequest struct {
_ struct{} `fidl2:"s,16,0"`
Arg string
}
-var _mWithAndWithoutRequestResponseWithRequestNoResponseRequest = _bindings.CreateLazyMarshaler(WithAndWithoutRequestResponseWithRequestNoResponseRequest{})
+var _mwithAndWithoutRequestResponseWithRequestNoResponseRequest = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithRequestNoResponseRequest{})
-func (msg *WithAndWithoutRequestResponseWithRequestNoResponseRequest) Marshaler() _bindings.Marshaler {
- return _mWithAndWithoutRequestResponseWithRequestNoResponseRequest
+func (msg *withAndWithoutRequestResponseWithRequestNoResponseRequest) Marshaler() _bindings.Marshaler {
+ return _mwithAndWithoutRequestResponseWithRequestNoResponseRequest
}
// Implements Payload.
-func (_ *WithAndWithoutRequestResponseWithRequestNoResponseRequest) InlineAlignment() int {
+func (_ *withAndWithoutRequestResponseWithRequestNoResponseRequest) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *WithAndWithoutRequestResponseWithRequestNoResponseRequest) InlineSize() int {
+func (_ *withAndWithoutRequestResponseWithRequestNoResponseRequest) InlineSize() int {
return 16
}
-type WithAndWithoutRequestResponseWithRequestEmptyResponseRequest struct {
+type withAndWithoutRequestResponseWithRequestEmptyResponseRequest struct {
_ struct{} `fidl2:"s,16,0"`
Arg string
}
-var _mWithAndWithoutRequestResponseWithRequestEmptyResponseRequest = _bindings.CreateLazyMarshaler(WithAndWithoutRequestResponseWithRequestEmptyResponseRequest{})
+var _mwithAndWithoutRequestResponseWithRequestEmptyResponseRequest = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithRequestEmptyResponseRequest{})
-func (msg *WithAndWithoutRequestResponseWithRequestEmptyResponseRequest) Marshaler() _bindings.Marshaler {
- return _mWithAndWithoutRequestResponseWithRequestEmptyResponseRequest
+func (msg *withAndWithoutRequestResponseWithRequestEmptyResponseRequest) Marshaler() _bindings.Marshaler {
+ return _mwithAndWithoutRequestResponseWithRequestEmptyResponseRequest
}
// Implements Payload.
-func (_ *WithAndWithoutRequestResponseWithRequestEmptyResponseRequest) InlineAlignment() int {
+func (_ *withAndWithoutRequestResponseWithRequestEmptyResponseRequest) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *WithAndWithoutRequestResponseWithRequestEmptyResponseRequest) InlineSize() int {
+func (_ *withAndWithoutRequestResponseWithRequestEmptyResponseRequest) InlineSize() int {
return 16
}
-type WithAndWithoutRequestResponseWithRequestWithResponseRequest struct {
+type withAndWithoutRequestResponseWithRequestWithResponseRequest struct {
_ struct{} `fidl2:"s,16,0"`
Arg string
}
-var _mWithAndWithoutRequestResponseWithRequestWithResponseRequest = _bindings.CreateLazyMarshaler(WithAndWithoutRequestResponseWithRequestWithResponseRequest{})
+var _mwithAndWithoutRequestResponseWithRequestWithResponseRequest = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithRequestWithResponseRequest{})
-func (msg *WithAndWithoutRequestResponseWithRequestWithResponseRequest) Marshaler() _bindings.Marshaler {
- return _mWithAndWithoutRequestResponseWithRequestWithResponseRequest
+func (msg *withAndWithoutRequestResponseWithRequestWithResponseRequest) Marshaler() _bindings.Marshaler {
+ return _mwithAndWithoutRequestResponseWithRequestWithResponseRequest
}
// Implements Payload.
-func (_ *WithAndWithoutRequestResponseWithRequestWithResponseRequest) InlineAlignment() int {
+func (_ *withAndWithoutRequestResponseWithRequestWithResponseRequest) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *WithAndWithoutRequestResponseWithRequestWithResponseRequest) InlineSize() int {
+func (_ *withAndWithoutRequestResponseWithRequestWithResponseRequest) InlineSize() int {
return 16
}
-type WithAndWithoutRequestResponseWithRequestWithResponseResponse struct {
+type withAndWithoutRequestResponseWithRequestWithResponseResponse struct {
_ struct{} `fidl2:"s,16,0"`
Ret string
}
-var _mWithAndWithoutRequestResponseWithRequestWithResponseResponse = _bindings.CreateLazyMarshaler(WithAndWithoutRequestResponseWithRequestWithResponseResponse{})
+var _mwithAndWithoutRequestResponseWithRequestWithResponseResponse = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithRequestWithResponseResponse{})
-func (msg *WithAndWithoutRequestResponseWithRequestWithResponseResponse) Marshaler() _bindings.Marshaler {
- return _mWithAndWithoutRequestResponseWithRequestWithResponseResponse
+func (msg *withAndWithoutRequestResponseWithRequestWithResponseResponse) Marshaler() _bindings.Marshaler {
+ return _mwithAndWithoutRequestResponseWithRequestWithResponseResponse
}
// Implements Payload.
-func (_ *WithAndWithoutRequestResponseWithRequestWithResponseResponse) InlineAlignment() int {
+func (_ *withAndWithoutRequestResponseWithRequestWithResponseResponse) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *WithAndWithoutRequestResponseWithRequestWithResponseResponse) InlineSize() int {
+func (_ *withAndWithoutRequestResponseWithRequestWithResponseResponse) InlineSize() int {
return 16
}
-type WithAndWithoutRequestResponseOnWithResponseResponse struct {
+type withAndWithoutRequestResponseOnWithResponseResponse struct {
_ struct{} `fidl2:"s,16,0"`
Ret string
}
-var _mWithAndWithoutRequestResponseOnWithResponseResponse = _bindings.CreateLazyMarshaler(WithAndWithoutRequestResponseOnWithResponseResponse{})
+var _mwithAndWithoutRequestResponseOnWithResponseResponse = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseOnWithResponseResponse{})
-func (msg *WithAndWithoutRequestResponseOnWithResponseResponse) Marshaler() _bindings.Marshaler {
- return _mWithAndWithoutRequestResponseOnWithResponseResponse
+func (msg *withAndWithoutRequestResponseOnWithResponseResponse) Marshaler() _bindings.Marshaler {
+ return _mwithAndWithoutRequestResponseOnWithResponseResponse
}
// Implements Payload.
-func (_ *WithAndWithoutRequestResponseOnWithResponseResponse) InlineAlignment() int {
+func (_ *withAndWithoutRequestResponseOnWithResponseResponse) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *WithAndWithoutRequestResponseOnWithResponseResponse) InlineSize() int {
+func (_ *withAndWithoutRequestResponseOnWithResponseResponse) InlineSize() int {
return 16
}
@@ -174,13 +303,13 @@ func (p *WithAndWithoutRequestResponseInterface) NoRequestEmptyResponse() error
func (p *WithAndWithoutRequestResponseInterface) NoRequestWithResponse() (string, error) {
var req_ _bindings.Payload
- resp_ := &WithAndWithoutRequestResponseNoRequestWithResponseResponse{}
+ resp_ := &withAndWithoutRequestResponseNoRequestWithResponseResponse{}
err := ((*_bindings.ChannelProxy)(p)).Call(WithAndWithoutRequestResponseNoRequestWithResponseOrdinal, req_, resp_)
return resp_.Ret, err
}
func (p *WithAndWithoutRequestResponseInterface) WithRequestNoResponse(arg string) error {
- req_ := &WithAndWithoutRequestResponseWithRequestNoResponseRequest{
+ req_ := &withAndWithoutRequestResponseWithRequestNoResponseRequest{
Arg: arg,
}
err := ((*_bindings.ChannelProxy)(p)).Send(WithAndWithoutRequestResponseWithRequestNoResponseOrdinal, req_)
@@ -188,7 +317,7 @@ func (p *WithAndWithoutRequestResponseInterface) WithRequestNoResponse(arg strin
}
func (p *WithAndWithoutRequestResponseInterface) WithRequestEmptyResponse(arg string) error {
- req_ := &WithAndWithoutRequestResponseWithRequestEmptyResponseRequest{
+ req_ := &withAndWithoutRequestResponseWithRequestEmptyResponseRequest{
Arg: arg,
}
var resp_ _bindings.Payload
@@ -197,10 +326,10 @@ func (p *WithAndWithoutRequestResponseInterface) WithRequestEmptyResponse(arg st
}
func (p *WithAndWithoutRequestResponseInterface) WithRequestWithResponse(arg string) (string, error) {
- req_ := &WithAndWithoutRequestResponseWithRequestWithResponseRequest{
+ req_ := &withAndWithoutRequestResponseWithRequestWithResponseRequest{
Arg: arg,
}
- resp_ := &WithAndWithoutRequestResponseWithRequestWithResponseResponse{}
+ resp_ := &withAndWithoutRequestResponseWithRequestWithResponseResponse{}
err := ((*_bindings.ChannelProxy)(p)).Call(WithAndWithoutRequestResponseWithRequestWithResponseOrdinal, req_, resp_)
return resp_.Ret, err
}
@@ -212,7 +341,7 @@ func (p *WithAndWithoutRequestResponseInterface) ExpectOnEmptyResponse() error {
}
func (p *WithAndWithoutRequestResponseInterface) ExpectOnWithResponse() (string, error) {
- resp_ := &WithAndWithoutRequestResponseOnWithResponseResponse{}
+ resp_ := &withAndWithoutRequestResponseOnWithResponseResponse{}
err := ((*_bindings.ChannelProxy)(p)).Recv(WithAndWithoutRequestResponseOnWithResponseOrdinal, resp_)
return resp_.Ret, err
}
@@ -255,30 +384,30 @@ func (s *WithAndWithoutRequestResponseStub) DispatchNew(ord uint32, b_ []byte, h
return nil, err_
case WithAndWithoutRequestResponseNoRequestWithResponseOrdinal:
ret, err_ := s.Impl.NoRequestWithResponse()
- out_ := WithAndWithoutRequestResponseNoRequestWithResponseResponse{}
+ out_ := withAndWithoutRequestResponseNoRequestWithResponseResponse{}
out_.Ret = ret
return &out_, err_
case WithAndWithoutRequestResponseWithRequestNoResponseOrdinal:
- in_ := WithAndWithoutRequestResponseWithRequestNoResponseRequest{}
+ in_ := withAndWithoutRequestResponseWithRequestNoResponseRequest{}
if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
return nil, err_
}
err_ := s.Impl.WithRequestNoResponse(in_.Arg)
return nil, err_
case WithAndWithoutRequestResponseWithRequestEmptyResponseOrdinal:
- in_ := WithAndWithoutRequestResponseWithRequestEmptyResponseRequest{}
+ in_ := withAndWithoutRequestResponseWithRequestEmptyResponseRequest{}
if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
return nil, err_
}
err_ := s.Impl.WithRequestEmptyResponse(in_.Arg)
return nil, err_
case WithAndWithoutRequestResponseWithRequestWithResponseOrdinal:
- in_ := WithAndWithoutRequestResponseWithRequestWithResponseRequest{}
+ in_ := withAndWithoutRequestResponseWithRequestWithResponseRequest{}
if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
return nil, err_
}
ret, err_ := s.Impl.WithRequestWithResponse(in_.Arg)
- out_ := WithAndWithoutRequestResponseWithRequestWithResponseResponse{}
+ out_ := withAndWithoutRequestResponseWithRequestWithResponseResponse{}
out_.Ret = ret
return &out_, err_
}
@@ -304,13 +433,135 @@ func (p *WithAndWithoutRequestResponseEventProxy) OnEmptyResponse() error {
return ((*_bindings.ChannelProxy)(p)).Send(WithAndWithoutRequestResponseOnEmptyResponseOrdinal, event_)
}
func (p *WithAndWithoutRequestResponseEventProxy) OnWithResponse(ret string) error {
- event_ := &WithAndWithoutRequestResponseOnWithResponseResponse{
+ event_ := &withAndWithoutRequestResponseOnWithResponseResponse{
Ret: ret,
}
return ((*_bindings.ChannelProxy)(p)).Send(WithAndWithoutRequestResponseOnWithResponseOrdinal, event_)
}
+const (
+ WithErrorSyntaxErrorAsPrimitiveOrdinal uint32 = 2069369145
+ WithErrorSyntaxErrorAsPrimitiveGenOrdinal uint32 = 2069369145
+ WithErrorSyntaxErrorAsEnumOrdinal uint32 = 1284890143
+ WithErrorSyntaxErrorAsEnumGenOrdinal uint32 = 1284890143
+)
+
+type withErrorSyntaxErrorAsPrimitiveResponse struct {
+ _ struct{} `fidl2:"s,8,0"`
+ Result WithErrorSyntaxErrorAsPrimitiveResult
+}
+
+var _mwithErrorSyntaxErrorAsPrimitiveResponse = _bindings.CreateLazyMarshaler(withErrorSyntaxErrorAsPrimitiveResponse{})
+
+func (msg *withErrorSyntaxErrorAsPrimitiveResponse) Marshaler() _bindings.Marshaler {
+ return _mwithErrorSyntaxErrorAsPrimitiveResponse
+}
+
+// Implements Payload.
+func (_ *withErrorSyntaxErrorAsPrimitiveResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *withErrorSyntaxErrorAsPrimitiveResponse) InlineSize() int {
+ return 8
+}
+
+type withErrorSyntaxErrorAsEnumResponse struct {
+ _ struct{} `fidl2:"s,8,0"`
+ Result WithErrorSyntaxErrorAsEnumResult
+}
+
+var _mwithErrorSyntaxErrorAsEnumResponse = _bindings.CreateLazyMarshaler(withErrorSyntaxErrorAsEnumResponse{})
+
+func (msg *withErrorSyntaxErrorAsEnumResponse) Marshaler() _bindings.Marshaler {
+ return _mwithErrorSyntaxErrorAsEnumResponse
+}
+
+// Implements Payload.
+func (_ *withErrorSyntaxErrorAsEnumResponse) InlineAlignment() int {
+ return 0
+}
+
+// Implements Payload.
+func (_ *withErrorSyntaxErrorAsEnumResponse) InlineSize() int {
+ return 8
+}
+
+type WithErrorSyntaxInterface _bindings.ChannelProxy
+
+
+func (p *WithErrorSyntaxInterface) ErrorAsPrimitive() (WithErrorSyntaxErrorAsPrimitiveResult, error) {
+ var req_ _bindings.Payload
+ resp_ := &withErrorSyntaxErrorAsPrimitiveResponse{}
+ err := ((*_bindings.ChannelProxy)(p)).Call(WithErrorSyntaxErrorAsPrimitiveOrdinal, req_, resp_)
+ return resp_.Result, err
+}
+
+func (p *WithErrorSyntaxInterface) ErrorAsEnum() (WithErrorSyntaxErrorAsEnumResult, error) {
+ var req_ _bindings.Payload
+ resp_ := &withErrorSyntaxErrorAsEnumResponse{}
+ err := ((*_bindings.ChannelProxy)(p)).Call(WithErrorSyntaxErrorAsEnumOrdinal, req_, resp_)
+ return resp_.Result, err
+}
+
+
+type WithErrorSyntax interface {
+ ErrorAsPrimitive() (WithErrorSyntaxErrorAsPrimitiveResult, error)
+ ErrorAsEnum() (WithErrorSyntaxErrorAsEnumResult, error)
+}
+
+type WithErrorSyntaxTransitionalBase struct {}
+
+
+type WithErrorSyntaxInterfaceRequest _bindings.InterfaceRequest
+
+func NewWithErrorSyntaxInterfaceRequest() (WithErrorSyntaxInterfaceRequest, *WithErrorSyntaxInterface, error) {
+ req, cli, err := _bindings.NewInterfaceRequest()
+ return WithErrorSyntaxInterfaceRequest(req), (*WithErrorSyntaxInterface)(cli), err
+}
+
+type WithErrorSyntaxStub struct {
+ Impl WithErrorSyntax
+}
+
+func (s *WithErrorSyntaxStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
+ return s.DispatchNew(ord, b_, h_)
+}
+
+func (s *WithErrorSyntaxStub) DispatchNew(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Message, error) {
+ switch ord {
+ case WithErrorSyntaxErrorAsPrimitiveOrdinal:
+ result, err_ := s.Impl.ErrorAsPrimitive()
+ out_ := withErrorSyntaxErrorAsPrimitiveResponse{}
+ out_.Result = result
+ return &out_, err_
+ case WithErrorSyntaxErrorAsEnumOrdinal:
+ result, err_ := s.Impl.ErrorAsEnum()
+ out_ := withErrorSyntaxErrorAsEnumResponse{}
+ out_.Result = result
+ return &out_, err_
+ }
+ return nil, _bindings.ErrUnknownOrdinal
+}
+type WithErrorSyntaxService struct {
+ _bindings.BindingSet
+}
+
+func (s *WithErrorSyntaxService) Add(impl WithErrorSyntax, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) {
+ return s.BindingSet.Add(&WithErrorSyntaxStub{Impl: impl}, c, onError)
+}
+
+func (s *WithErrorSyntaxService) EventProxyFor(key _bindings.BindingKey) (*WithErrorSyntaxEventProxy, bool) {
+ pxy, err := s.BindingSet.ProxyFor(key)
+ return (*WithErrorSyntaxEventProxy)(pxy), err
+}
+
+type WithErrorSyntaxEventProxy _bindings.ChannelProxy
+
+
+
const (
OvernetInternalProtocolMethodAOrdinal uint32 = 1993818253
OvernetInternalProtocolMethodAGenOrdinal uint32 = 1993818253
@@ -320,90 +571,90 @@ const (
OvernetInternalProtocolMethodBGenOrdinal uint32 = 952134976
)
-type OvernetInternalProtocolMethodARequest struct {
+type overnetInternalProtocolMethodARequest struct {
_ struct{} `fidl2:"s,16,0"`
A int64
B int64
}
-var _mOvernetInternalProtocolMethodARequest = _bindings.CreateLazyMarshaler(OvernetInternalProtocolMethodARequest{})
+var _movernetInternalProtocolMethodARequest = _bindings.CreateLazyMarshaler(overnetInternalProtocolMethodARequest{})
-func (msg *OvernetInternalProtocolMethodARequest) Marshaler() _bindings.Marshaler {
- return _mOvernetInternalProtocolMethodARequest
+func (msg *overnetInternalProtocolMethodARequest) Marshaler() _bindings.Marshaler {
+ return _movernetInternalProtocolMethodARequest
}
// Implements Payload.
-func (_ *OvernetInternalProtocolMethodARequest) InlineAlignment() int {
+func (_ *overnetInternalProtocolMethodARequest) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *OvernetInternalProtocolMethodARequest) InlineSize() int {
+func (_ *overnetInternalProtocolMethodARequest) InlineSize() int {
return 16
}
-type OvernetInternalProtocolEventAResponse struct {
+type overnetInternalProtocolEventAResponse struct {
_ struct{} `fidl2:"s,16,0"`
A int64
B int64
}
-var _mOvernetInternalProtocolEventAResponse = _bindings.CreateLazyMarshaler(OvernetInternalProtocolEventAResponse{})
+var _movernetInternalProtocolEventAResponse = _bindings.CreateLazyMarshaler(overnetInternalProtocolEventAResponse{})
-func (msg *OvernetInternalProtocolEventAResponse) Marshaler() _bindings.Marshaler {
- return _mOvernetInternalProtocolEventAResponse
+func (msg *overnetInternalProtocolEventAResponse) Marshaler() _bindings.Marshaler {
+ return _movernetInternalProtocolEventAResponse
}
// Implements Payload.
-func (_ *OvernetInternalProtocolEventAResponse) InlineAlignment() int {
+func (_ *overnetInternalProtocolEventAResponse) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *OvernetInternalProtocolEventAResponse) InlineSize() int {
+func (_ *overnetInternalProtocolEventAResponse) InlineSize() int {
return 16
}
-type OvernetInternalProtocolMethodBRequest struct {
+type overnetInternalProtocolMethodBRequest struct {
_ struct{} `fidl2:"s,16,0"`
A int64
B int64
}
-var _mOvernetInternalProtocolMethodBRequest = _bindings.CreateLazyMarshaler(OvernetInternalProtocolMethodBRequest{})
+var _movernetInternalProtocolMethodBRequest = _bindings.CreateLazyMarshaler(overnetInternalProtocolMethodBRequest{})
-func (msg *OvernetInternalProtocolMethodBRequest) Marshaler() _bindings.Marshaler {
- return _mOvernetInternalProtocolMethodBRequest
+func (msg *overnetInternalProtocolMethodBRequest) Marshaler() _bindings.Marshaler {
+ return _movernetInternalProtocolMethodBRequest
}
// Implements Payload.
-func (_ *OvernetInternalProtocolMethodBRequest) InlineAlignment() int {
+func (_ *overnetInternalProtocolMethodBRequest) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *OvernetInternalProtocolMethodBRequest) InlineSize() int {
+func (_ *overnetInternalProtocolMethodBRequest) InlineSize() int {
return 16
}
-type OvernetInternalProtocolMethodBResponse struct {
+type overnetInternalProtocolMethodBResponse struct {
_ struct{} `fidl2:"s,8,0"`
Result int64
}
-var _mOvernetInternalProtocolMethodBResponse = _bindings.CreateLazyMarshaler(OvernetInternalProtocolMethodBResponse{})
+var _movernetInternalProtocolMethodBResponse = _bindings.CreateLazyMarshaler(overnetInternalProtocolMethodBResponse{})
-func (msg *OvernetInternalProtocolMethodBResponse) Marshaler() _bindings.Marshaler {
- return _mOvernetInternalProtocolMethodBResponse
+func (msg *overnetInternalProtocolMethodBResponse) Marshaler() _bindings.Marshaler {
+ return _movernetInternalProtocolMethodBResponse
}
// Implements Payload.
-func (_ *OvernetInternalProtocolMethodBResponse) InlineAlignment() int {
+func (_ *overnetInternalProtocolMethodBResponse) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *OvernetInternalProtocolMethodBResponse) InlineSize() int {
+func (_ *overnetInternalProtocolMethodBResponse) InlineSize() int {
return 8
}
@@ -411,7 +662,7 @@ type OvernetInternalProtocolInterface _bindings.ChannelProxy
func (p *OvernetInternalProtocolInterface) MethodA(a int64,b int64) error {
- req_ := &OvernetInternalProtocolMethodARequest{
+ req_ := &overnetInternalProtocolMethodARequest{
A: a,
B: b,
}
@@ -420,17 +671,17 @@ func (p *OvernetInternalProtocolInterface) MethodA(a int64,b int64) error {
}
func (p *OvernetInternalProtocolInterface) ExpectEventA() (int64, int64, error) {
- resp_ := &OvernetInternalProtocolEventAResponse{}
+ resp_ := &overnetInternalProtocolEventAResponse{}
err := ((*_bindings.ChannelProxy)(p)).Recv(OvernetInternalProtocolEventAOrdinal, resp_)
return resp_.A, resp_.B, err
}
func (p *OvernetInternalProtocolInterface) MethodB(a int64,b int64) (int64, error) {
- req_ := &OvernetInternalProtocolMethodBRequest{
+ req_ := &overnetInternalProtocolMethodBRequest{
A: a,
B: b,
}
- resp_ := &OvernetInternalProtocolMethodBResponse{}
+ resp_ := &overnetInternalProtocolMethodBResponse{}
err := ((*_bindings.ChannelProxy)(p)).Call(OvernetInternalProtocolMethodBOrdinal, req_, resp_)
return resp_.Result, err
}
@@ -462,19 +713,19 @@ func (s *OvernetInternalProtocolStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.H
func (s *OvernetInternalProtocolStub) DispatchNew(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Message, error) {
switch ord {
case OvernetInternalProtocolMethodAOrdinal:
- in_ := OvernetInternalProtocolMethodARequest{}
+ in_ := overnetInternalProtocolMethodARequest{}
if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
return nil, err_
}
err_ := s.Impl.MethodA(in_.A,in_.B)
return nil, err_
case OvernetInternalProtocolMethodBOrdinal:
- in_ := OvernetInternalProtocolMethodBRequest{}
+ in_ := overnetInternalProtocolMethodBRequest{}
if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
return nil, err_
}
result, err_ := s.Impl.MethodB(in_.A,in_.B)
- out_ := OvernetInternalProtocolMethodBResponse{}
+ out_ := overnetInternalProtocolMethodBResponse{}
out_.Result = result
return &out_, err_
}
@@ -496,7 +747,7 @@ func (s *OvernetInternalProtocolService) EventProxyFor(key _bindings.BindingKey)
type OvernetInternalProtocolEventProxy _bindings.ChannelProxy
func (p *OvernetInternalProtocolEventProxy) EventA(a int64,b int64) error {
- event_ := &OvernetInternalProtocolEventAResponse{
+ event_ := &overnetInternalProtocolEventAResponse{
A: a,
B: b,
}
@@ -513,90 +764,90 @@ const (
SocketControlProtocolMethodBGenOrdinal uint32 = 677342235
)
-type SocketControlProtocolMethodARequest struct {
+type socketControlProtocolMethodARequest struct {
_ struct{} `fidl2:"s,16,0"`
A int64
B int64
}
-var _mSocketControlProtocolMethodARequest = _bindings.CreateLazyMarshaler(SocketControlProtocolMethodARequest{})
+var _msocketControlProtocolMethodARequest = _bindings.CreateLazyMarshaler(socketControlProtocolMethodARequest{})
-func (msg *SocketControlProtocolMethodARequest) Marshaler() _bindings.Marshaler {
- return _mSocketControlProtocolMethodARequest
+func (msg *socketControlProtocolMethodARequest) Marshaler() _bindings.Marshaler {
+ return _msocketControlProtocolMethodARequest
}
// Implements Payload.
-func (_ *SocketControlProtocolMethodARequest) InlineAlignment() int {
+func (_ *socketControlProtocolMethodARequest) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *SocketControlProtocolMethodARequest) InlineSize() int {
+func (_ *socketControlProtocolMethodARequest) InlineSize() int {
return 16
}
-type SocketControlProtocolEventAResponse struct {
+type socketControlProtocolEventAResponse struct {
_ struct{} `fidl2:"s,16,0"`
A int64
B int64
}
-var _mSocketControlProtocolEventAResponse = _bindings.CreateLazyMarshaler(SocketControlProtocolEventAResponse{})
+var _msocketControlProtocolEventAResponse = _bindings.CreateLazyMarshaler(socketControlProtocolEventAResponse{})
-func (msg *SocketControlProtocolEventAResponse) Marshaler() _bindings.Marshaler {
- return _mSocketControlProtocolEventAResponse
+func (msg *socketControlProtocolEventAResponse) Marshaler() _bindings.Marshaler {
+ return _msocketControlProtocolEventAResponse
}
// Implements Payload.
-func (_ *SocketControlProtocolEventAResponse) InlineAlignment() int {
+func (_ *socketControlProtocolEventAResponse) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *SocketControlProtocolEventAResponse) InlineSize() int {
+func (_ *socketControlProtocolEventAResponse) InlineSize() int {
return 16
}
-type SocketControlProtocolMethodBRequest struct {
+type socketControlProtocolMethodBRequest struct {
_ struct{} `fidl2:"s,16,0"`
A int64
B int64
}
-var _mSocketControlProtocolMethodBRequest = _bindings.CreateLazyMarshaler(SocketControlProtocolMethodBRequest{})
+var _msocketControlProtocolMethodBRequest = _bindings.CreateLazyMarshaler(socketControlProtocolMethodBRequest{})
-func (msg *SocketControlProtocolMethodBRequest) Marshaler() _bindings.Marshaler {
- return _mSocketControlProtocolMethodBRequest
+func (msg *socketControlProtocolMethodBRequest) Marshaler() _bindings.Marshaler {
+ return _msocketControlProtocolMethodBRequest
}
// Implements Payload.
-func (_ *SocketControlProtocolMethodBRequest) InlineAlignment() int {
+func (_ *socketControlProtocolMethodBRequest) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *SocketControlProtocolMethodBRequest) InlineSize() int {
+func (_ *socketControlProtocolMethodBRequest) InlineSize() int {
return 16
}
-type SocketControlProtocolMethodBResponse struct {
+type socketControlProtocolMethodBResponse struct {
_ struct{} `fidl2:"s,8,0"`
Result int64
}
-var _mSocketControlProtocolMethodBResponse = _bindings.CreateLazyMarshaler(SocketControlProtocolMethodBResponse{})
+var _msocketControlProtocolMethodBResponse = _bindings.CreateLazyMarshaler(socketControlProtocolMethodBResponse{})
-func (msg *SocketControlProtocolMethodBResponse) Marshaler() _bindings.Marshaler {
- return _mSocketControlProtocolMethodBResponse
+func (msg *socketControlProtocolMethodBResponse) Marshaler() _bindings.Marshaler {
+ return _msocketControlProtocolMethodBResponse
}
// Implements Payload.
-func (_ *SocketControlProtocolMethodBResponse) InlineAlignment() int {
+func (_ *socketControlProtocolMethodBResponse) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *SocketControlProtocolMethodBResponse) InlineSize() int {
+func (_ *socketControlProtocolMethodBResponse) InlineSize() int {
return 8
}
@@ -604,7 +855,7 @@ type SocketControlProtocolInterface _bindings.SocketControlProxy
func (p *SocketControlProtocolInterface) MethodA(a int64,b int64) error {
- req_ := &SocketControlProtocolMethodARequest{
+ req_ := &socketControlProtocolMethodARequest{
A: a,
B: b,
}
@@ -613,17 +864,17 @@ func (p *SocketControlProtocolInterface) MethodA(a int64,b int64) error {
}
func (p *SocketControlProtocolInterface) ExpectEventA() (int64, int64, error) {
- resp_ := &SocketControlProtocolEventAResponse{}
+ resp_ := &socketControlProtocolEventAResponse{}
err := ((*_bindings.SocketControlProxy)(p)).Recv(SocketControlProtocolEventAOrdinal, resp_)
return resp_.A, resp_.B, err
}
func (p *SocketControlProtocolInterface) MethodB(a int64,b int64) (int64, error) {
- req_ := &SocketControlProtocolMethodBRequest{
+ req_ := &socketControlProtocolMethodBRequest{
A: a,
B: b,
}
- resp_ := &SocketControlProtocolMethodBResponse{}
+ resp_ := &socketControlProtocolMethodBResponse{}
err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlProtocolMethodBOrdinal, req_, resp_)
return resp_.Result, err
}
@@ -649,19 +900,19 @@ func (s *SocketControlProtocolStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Han
func (s *SocketControlProtocolStub) DispatchNew(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Message, error) {
switch ord {
case SocketControlProtocolMethodAOrdinal:
- in_ := SocketControlProtocolMethodARequest{}
+ in_ := socketControlProtocolMethodARequest{}
if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
return nil, err_
}
err_ := s.Impl.MethodA(in_.A,in_.B)
return nil, err_
case SocketControlProtocolMethodBOrdinal:
- in_ := SocketControlProtocolMethodBRequest{}
+ in_ := socketControlProtocolMethodBRequest{}
if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
return nil, err_
}
result, err_ := s.Impl.MethodB(in_.A,in_.B)
- out_ := SocketControlProtocolMethodBResponse{}
+ out_ := socketControlProtocolMethodBResponse{}
out_.Result = result
return &out_, err_
}
@@ -671,7 +922,7 @@ func (s *SocketControlProtocolStub) DispatchNew(ord uint32, b_ []byte, h_ []_zx.
type SocketControlProtocolEventProxy _bindings.SocketControlProxy
func (p *SocketControlProtocolEventProxy) EventA(a int64,b int64) error {
- event_ := &SocketControlProtocolEventAResponse{
+ event_ := &socketControlProtocolEventAResponse{
A: a,
B: b,
}
@@ -688,90 +939,90 @@ const (
ChannelProtocolMethodBGenOrdinal uint32 = 180770075
)
-type ChannelProtocolMethodARequest struct {
+type channelProtocolMethodARequest struct {
_ struct{} `fidl2:"s,16,0"`
A int64
B int64
}
-var _mChannelProtocolMethodARequest = _bindings.CreateLazyMarshaler(ChannelProtocolMethodARequest{})
+var _mchannelProtocolMethodARequest = _bindings.CreateLazyMarshaler(channelProtocolMethodARequest{})
-func (msg *ChannelProtocolMethodARequest) Marshaler() _bindings.Marshaler {
- return _mChannelProtocolMethodARequest
+func (msg *channelProtocolMethodARequest) Marshaler() _bindings.Marshaler {
+ return _mchannelProtocolMethodARequest
}
// Implements Payload.
-func (_ *ChannelProtocolMethodARequest) InlineAlignment() int {
+func (_ *channelProtocolMethodARequest) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *ChannelProtocolMethodARequest) InlineSize() int {
+func (_ *channelProtocolMethodARequest) InlineSize() int {
return 16
}
-type ChannelProtocolEventAResponse struct {
+type channelProtocolEventAResponse struct {
_ struct{} `fidl2:"s,16,0"`
A int64
B int64
}
-var _mChannelProtocolEventAResponse = _bindings.CreateLazyMarshaler(ChannelProtocolEventAResponse{})
+var _mchannelProtocolEventAResponse = _bindings.CreateLazyMarshaler(channelProtocolEventAResponse{})
-func (msg *ChannelProtocolEventAResponse) Marshaler() _bindings.Marshaler {
- return _mChannelProtocolEventAResponse
+func (msg *channelProtocolEventAResponse) Marshaler() _bindings.Marshaler {
+ return _mchannelProtocolEventAResponse
}
// Implements Payload.
-func (_ *ChannelProtocolEventAResponse) InlineAlignment() int {
+func (_ *channelProtocolEventAResponse) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *ChannelProtocolEventAResponse) InlineSize() int {
+func (_ *channelProtocolEventAResponse) InlineSize() int {
return 16
}
-type ChannelProtocolMethodBRequest struct {
+type channelProtocolMethodBRequest struct {
_ struct{} `fidl2:"s,16,0"`
A int64
B int64
}
-var _mChannelProtocolMethodBRequest = _bindings.CreateLazyMarshaler(ChannelProtocolMethodBRequest{})
+var _mchannelProtocolMethodBRequest = _bindings.CreateLazyMarshaler(channelProtocolMethodBRequest{})
-func (msg *ChannelProtocolMethodBRequest) Marshaler() _bindings.Marshaler {
- return _mChannelProtocolMethodBRequest
+func (msg *channelProtocolMethodBRequest) Marshaler() _bindings.Marshaler {
+ return _mchannelProtocolMethodBRequest
}
// Implements Payload.
-func (_ *ChannelProtocolMethodBRequest) InlineAlignment() int {
+func (_ *channelProtocolMethodBRequest) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *ChannelProtocolMethodBRequest) InlineSize() int {
+func (_ *channelProtocolMethodBRequest) InlineSize() int {
return 16
}
-type ChannelProtocolMethodBResponse struct {
+type channelProtocolMethodBResponse struct {
_ struct{} `fidl2:"s,8,0"`
Result int64
}
-var _mChannelProtocolMethodBResponse = _bindings.CreateLazyMarshaler(ChannelProtocolMethodBResponse{})
+var _mchannelProtocolMethodBResponse = _bindings.CreateLazyMarshaler(channelProtocolMethodBResponse{})
-func (msg *ChannelProtocolMethodBResponse) Marshaler() _bindings.Marshaler {
- return _mChannelProtocolMethodBResponse
+func (msg *channelProtocolMethodBResponse) Marshaler() _bindings.Marshaler {
+ return _mchannelProtocolMethodBResponse
}
// Implements Payload.
-func (_ *ChannelProtocolMethodBResponse) InlineAlignment() int {
+func (_ *channelProtocolMethodBResponse) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *ChannelProtocolMethodBResponse) InlineSize() int {
+func (_ *channelProtocolMethodBResponse) InlineSize() int {
return 8
}
@@ -779,7 +1030,7 @@ type ChannelProtocolInterface _bindings.ChannelProxy
func (p *ChannelProtocolInterface) MethodA(a int64,b int64) error {
- req_ := &ChannelProtocolMethodARequest{
+ req_ := &channelProtocolMethodARequest{
A: a,
B: b,
}
@@ -788,17 +1039,17 @@ func (p *ChannelProtocolInterface) MethodA(a int64,b int64) error {
}
func (p *ChannelProtocolInterface) ExpectEventA() (int64, int64, error) {
- resp_ := &ChannelProtocolEventAResponse{}
+ resp_ := &channelProtocolEventAResponse{}
err := ((*_bindings.ChannelProxy)(p)).Recv(ChannelProtocolEventAOrdinal, resp_)
return resp_.A, resp_.B, err
}
func (p *ChannelProtocolInterface) MethodB(a int64,b int64) (int64, error) {
- req_ := &ChannelProtocolMethodBRequest{
+ req_ := &channelProtocolMethodBRequest{
A: a,
B: b,
}
- resp_ := &ChannelProtocolMethodBResponse{}
+ resp_ := &channelProtocolMethodBResponse{}
err := ((*_bindings.ChannelProxy)(p)).Call(ChannelProtocolMethodBOrdinal, req_, resp_)
return resp_.Result, err
}
@@ -830,19 +1081,19 @@ func (s *ChannelProtocolStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (
func (s *ChannelProtocolStub) DispatchNew(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Message, error) {
switch ord {
case ChannelProtocolMethodAOrdinal:
- in_ := ChannelProtocolMethodARequest{}
+ in_ := channelProtocolMethodARequest{}
if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
return nil, err_
}
err_ := s.Impl.MethodA(in_.A,in_.B)
return nil, err_
case ChannelProtocolMethodBOrdinal:
- in_ := ChannelProtocolMethodBRequest{}
+ in_ := channelProtocolMethodBRequest{}
if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
return nil, err_
}
result, err_ := s.Impl.MethodB(in_.A,in_.B)
- out_ := ChannelProtocolMethodBResponse{}
+ out_ := channelProtocolMethodBResponse{}
out_.Result = result
return &out_, err_
}
@@ -864,7 +1115,7 @@ func (s *ChannelProtocolService) EventProxyFor(key _bindings.BindingKey) (*Chann
type ChannelProtocolEventProxy _bindings.ChannelProxy
func (p *ChannelProtocolEventProxy) EventA(a int64,b int64) error {
- event_ := &ChannelProtocolEventAResponse{
+ event_ := &channelProtocolEventAResponse{
A: a,
B: b,
}
@@ -881,90 +1132,90 @@ const (
KitchenSinkMethodBGenOrdinal uint32 = 1999489700
)
-type KitchenSinkMethodARequest struct {
+type kitchenSinkMethodARequest struct {
_ struct{} `fidl2:"s,16,0"`
A int64
B int64
}
-var _mKitchenSinkMethodARequest = _bindings.CreateLazyMarshaler(KitchenSinkMethodARequest{})
+var _mkitchenSinkMethodARequest = _bindings.CreateLazyMarshaler(kitchenSinkMethodARequest{})
-func (msg *KitchenSinkMethodARequest) Marshaler() _bindings.Marshaler {
- return _mKitchenSinkMethodARequest
+func (msg *kitchenSinkMethodARequest) Marshaler() _bindings.Marshaler {
+ return _mkitchenSinkMethodARequest
}
// Implements Payload.
-func (_ *KitchenSinkMethodARequest) InlineAlignment() int {
+func (_ *kitchenSinkMethodARequest) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *KitchenSinkMethodARequest) InlineSize() int {
+func (_ *kitchenSinkMethodARequest) InlineSize() int {
return 16
}
-type KitchenSinkEventAResponse struct {
+type kitchenSinkEventAResponse struct {
_ struct{} `fidl2:"s,16,0"`
A int64
B int64
}
-var _mKitchenSinkEventAResponse = _bindings.CreateLazyMarshaler(KitchenSinkEventAResponse{})
+var _mkitchenSinkEventAResponse = _bindings.CreateLazyMarshaler(kitchenSinkEventAResponse{})
-func (msg *KitchenSinkEventAResponse) Marshaler() _bindings.Marshaler {
- return _mKitchenSinkEventAResponse
+func (msg *kitchenSinkEventAResponse) Marshaler() _bindings.Marshaler {
+ return _mkitchenSinkEventAResponse
}
// Implements Payload.
-func (_ *KitchenSinkEventAResponse) InlineAlignment() int {
+func (_ *kitchenSinkEventAResponse) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *KitchenSinkEventAResponse) InlineSize() int {
+func (_ *kitchenSinkEventAResponse) InlineSize() int {
return 16
}
-type KitchenSinkMethodBRequest struct {
+type kitchenSinkMethodBRequest struct {
_ struct{} `fidl2:"s,16,0"`
A int64
B int64
}
-var _mKitchenSinkMethodBRequest = _bindings.CreateLazyMarshaler(KitchenSinkMethodBRequest{})
+var _mkitchenSinkMethodBRequest = _bindings.CreateLazyMarshaler(kitchenSinkMethodBRequest{})
-func (msg *KitchenSinkMethodBRequest) Marshaler() _bindings.Marshaler {
- return _mKitchenSinkMethodBRequest
+func (msg *kitchenSinkMethodBRequest) Marshaler() _bindings.Marshaler {
+ return _mkitchenSinkMethodBRequest
}
// Implements Payload.
-func (_ *KitchenSinkMethodBRequest) InlineAlignment() int {
+func (_ *kitchenSinkMethodBRequest) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *KitchenSinkMethodBRequest) InlineSize() int {
+func (_ *kitchenSinkMethodBRequest) InlineSize() int {
return 16
}
-type KitchenSinkMethodBResponse struct {
+type kitchenSinkMethodBResponse struct {
_ struct{} `fidl2:"s,8,0"`
Result int64
}
-var _mKitchenSinkMethodBResponse = _bindings.CreateLazyMarshaler(KitchenSinkMethodBResponse{})
+var _mkitchenSinkMethodBResponse = _bindings.CreateLazyMarshaler(kitchenSinkMethodBResponse{})
-func (msg *KitchenSinkMethodBResponse) Marshaler() _bindings.Marshaler {
- return _mKitchenSinkMethodBResponse
+func (msg *kitchenSinkMethodBResponse) Marshaler() _bindings.Marshaler {
+ return _mkitchenSinkMethodBResponse
}
// Implements Payload.
-func (_ *KitchenSinkMethodBResponse) InlineAlignment() int {
+func (_ *kitchenSinkMethodBResponse) InlineAlignment() int {
return 0
}
// Implements Payload.
-func (_ *KitchenSinkMethodBResponse) InlineSize() int {
+func (_ *kitchenSinkMethodBResponse) InlineSize() int {
return 8
}
@@ -972,7 +1223,7 @@ type KitchenSinkInterface _bindings.ChannelProxy
func (p *KitchenSinkInterface) MethodA(a int64,b int64) error {
- req_ := &KitchenSinkMethodARequest{
+ req_ := &kitchenSinkMethodARequest{
A: a,
B: b,
}
@@ -981,17 +1232,17 @@ func (p *KitchenSinkInterface) MethodA(a int64,b int64) error {
}
func (p *KitchenSinkInterface) ExpectEventA() (int64, int64, error) {
- resp_ := &KitchenSinkEventAResponse{}
+ resp_ := &kitchenSinkEventAResponse{}
err := ((*_bindings.ChannelProxy)(p)).Recv(KitchenSinkEventAOrdinal, resp_)
return resp_.A, resp_.B, err
}
func (p *KitchenSinkInterface) MethodB(a int64,b int64) (int64, error) {
- req_ := &KitchenSinkMethodBRequest{
+ req_ := &kitchenSinkMethodBRequest{
A: a,
B: b,
}
- resp_ := &KitchenSinkMethodBResponse{}
+ resp_ := &kitchenSinkMethodBResponse{}
err := ((*_bindings.ChannelProxy)(p)).Call(KitchenSinkMethodBOrdinal, req_, resp_)
return resp_.Result, err
}
@@ -1023,19 +1274,19 @@ func (s *KitchenSinkStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bin
func (s *KitchenSinkStub) DispatchNew(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Message, error) {
switch ord {
case KitchenSinkMethodAOrdinal:
- in_ := KitchenSinkMethodARequest{}
+ in_ := kitchenSinkMethodARequest{}
if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
return nil, err_
}
err_ := s.Impl.MethodA(in_.A,in_.B)
return nil, err_
case KitchenSinkMethodBOrdinal:
- in_ := KitchenSinkMethodBRequest{}
+ in_ := kitchenSinkMethodBRequest{}
if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
return nil, err_
}
result, err_ := s.Impl.MethodB(in_.A,in_.B)
- out_ := KitchenSinkMethodBResponse{}
+ out_ := kitchenSinkMethodBResponse{}
out_.Result = result
return &out_, err_
}
@@ -1057,7 +1308,7 @@ func (s *KitchenSinkService) EventProxyFor(key _bindings.BindingKey) (*KitchenSi
type KitchenSinkEventProxy _bindings.ChannelProxy
func (p *KitchenSinkEventProxy) EventA(a int64,b int64) error {
- event_ := &KitchenSinkEventAResponse{
+ event_ := &kitchenSinkEventAResponse{
A: a,
B: b,
}
diff --git a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.h.golden b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.h.golden
index e3acfabff8c6d44de274c756aa2ce7780f8e87e6..8e9724a17e2e38cc19ab6867c91660cdb99f4054 100644
--- a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.h.golden
+++ b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.h.golden
@@ -8,6 +8,9 @@
namespace test {
namespace name {
+class WithErrorSyntax_ErrorAsPrimitive_Response;
+class WithErrorSyntax_ErrorAsPrimitive_Result;
+class WithErrorSyntax_ErrorAsEnum_Response;
#ifdef __Fuchsia__
class KitchenSink;
using KitchenSinkPtr = ::fidl::InterfacePtr<KitchenSink>;
@@ -58,6 +61,152 @@ class WithAndWithoutRequestResponse_Sync;
using WithAndWithoutRequestResponseSyncPtr = ::fidl::SynchronousInterfacePtr<WithAndWithoutRequestResponse>;
class WithAndWithoutRequestResponse_SyncProxy;
#endif // __Fuchsia__
+enum class ErrorEnun : uint32_t {
+ ERR_FOO = 1,
+ ERR_BAR = 2,
+};
+
+inline zx_status_t Clone(::test::name::ErrorEnun value,
+ ::test::name::ErrorEnun* result) {
+ *result = value;
+ return ZX_OK;
+}
+
+class WithErrorSyntax_ErrorAsEnum_Result;
+#ifdef __Fuchsia__
+class WithErrorSyntax;
+using WithErrorSyntaxPtr = ::fidl::InterfacePtr<WithErrorSyntax>;
+class WithErrorSyntax_Proxy;
+class WithErrorSyntax_Stub;
+class WithErrorSyntax_EventSender;
+class WithErrorSyntax_Sync;
+using WithErrorSyntaxSyncPtr = ::fidl::SynchronousInterfacePtr<WithErrorSyntax>;
+class WithErrorSyntax_SyncProxy;
+#endif // __Fuchsia__
+
+class WithErrorSyntax_ErrorAsPrimitive_Response {
+ public:
+ static const fidl_type_t* FidlType;
+
+ uint8_t __reserved = 0;
+
+ static inline ::std::unique_ptr<WithErrorSyntax_ErrorAsPrimitive_Response> New() { return ::std::make_unique<WithErrorSyntax_ErrorAsPrimitive_Response>(); }
+
+ void Encode(::fidl::Encoder* _encoder, size_t _offset);
+ static void Decode(::fidl::Decoder* _decoder, WithErrorSyntax_ErrorAsPrimitive_Response* value, size_t _offset);
+ zx_status_t Clone(WithErrorSyntax_ErrorAsPrimitive_Response* result) const;
+};
+
+bool operator==(const WithErrorSyntax_ErrorAsPrimitive_Response& _lhs, const WithErrorSyntax_ErrorAsPrimitive_Response& _rhs);
+inline bool operator!=(const WithErrorSyntax_ErrorAsPrimitive_Response& _lhs, const WithErrorSyntax_ErrorAsPrimitive_Response& _rhs) {
+ return !(_lhs == _rhs);
+}
+
+inline zx_status_t Clone(const ::test::name::WithErrorSyntax_ErrorAsPrimitive_Response& _value,
+ ::test::name::WithErrorSyntax_ErrorAsPrimitive_Response* _result) {
+ return _value.Clone(_result);
+}
+
+using WithErrorSyntax_ErrorAsPrimitive_ResponsePtr = ::std::unique_ptr<WithErrorSyntax_ErrorAsPrimitive_Response>;
+
+class WithErrorSyntax_ErrorAsPrimitive_Result {
+ public:
+ WithErrorSyntax_ErrorAsPrimitive_Result();
+ ~WithErrorSyntax_ErrorAsPrimitive_Result();
+
+ WithErrorSyntax_ErrorAsPrimitive_Result(WithErrorSyntax_ErrorAsPrimitive_Result&&);
+ WithErrorSyntax_ErrorAsPrimitive_Result& operator=(WithErrorSyntax_ErrorAsPrimitive_Result&&);
+
+ enum class Tag : fidl_union_tag_t {
+ kResponse = 0,
+ kErr = 1,
+ Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
+ };
+
+ static inline ::std::unique_ptr<WithErrorSyntax_ErrorAsPrimitive_Result> New() { return ::std::make_unique<WithErrorSyntax_ErrorAsPrimitive_Result>(); }
+
+ void Encode(::fidl::Encoder* _encoder, size_t _offset);
+ static void Decode(::fidl::Decoder* _decoder, WithErrorSyntax_ErrorAsPrimitive_Result* _value, size_t _offset);
+ zx_status_t Clone(WithErrorSyntax_ErrorAsPrimitive_Result* result) const;
+
+ bool has_invalid_tag() const { return Which() == Tag::Invalid; }
+
+ bool is_response() const { return Which() == Tag(0); }
+
+ WithErrorSyntax_ErrorAsPrimitive_Response& response() {
+ if (!is_response()) {
+ value_.emplace<0 + 1>();
+ }
+ return value_.template get<0 + 1>();
+ }
+
+ const WithErrorSyntax_ErrorAsPrimitive_Response& response() const { return value_.template get<0 + 1>(); }
+ void set_response(WithErrorSyntax_ErrorAsPrimitive_Response value);
+
+ bool is_err() const { return Which() == Tag(1); }
+
+ uint32_t& err() {
+ if (!is_err()) {
+ value_.emplace<1 + 1>();
+ }
+ return value_.template get<1 + 1>();
+ }
+
+ const uint32_t& err() const { return value_.template get<1 + 1>(); }
+ void set_err(uint32_t value);
+
+ Tag Which() const {
+ size_t index = value_.index();
+ if (index == 0) {
+ return Tag::Invalid;
+ } else {
+ return Tag(index - 1);
+ }
+ }
+
+ private:
+ friend bool operator==(const WithErrorSyntax_ErrorAsPrimitive_Result& _lhs, const WithErrorSyntax_ErrorAsPrimitive_Result& _rhs);
+
+ using Variant = fit::internal::variant<fit::internal::monostate, WithErrorSyntax_ErrorAsPrimitive_Response, uint32_t>;
+ Variant value_;
+};
+
+bool operator==(const WithErrorSyntax_ErrorAsPrimitive_Result& _lhs, const WithErrorSyntax_ErrorAsPrimitive_Result& _rhs);
+inline bool operator!=(const WithErrorSyntax_ErrorAsPrimitive_Result& _lhs, const WithErrorSyntax_ErrorAsPrimitive_Result& _rhs) {
+ return !(_lhs == _rhs);
+}
+
+inline zx_status_t Clone(const ::test::name::WithErrorSyntax_ErrorAsPrimitive_Result& value,
+ ::test::name::WithErrorSyntax_ErrorAsPrimitive_Result* result) {
+ return value.Clone(result);
+}
+
+using WithErrorSyntax_ErrorAsPrimitive_ResultPtr = ::std::unique_ptr<WithErrorSyntax_ErrorAsPrimitive_Result>;
+
+class WithErrorSyntax_ErrorAsEnum_Response {
+ public:
+ static const fidl_type_t* FidlType;
+
+ uint8_t __reserved = 0;
+
+ static inline ::std::unique_ptr<WithErrorSyntax_ErrorAsEnum_Response> New() { return ::std::make_unique<WithErrorSyntax_ErrorAsEnum_Response>(); }
+
+ void Encode(::fidl::Encoder* _encoder, size_t _offset);
+ static void Decode(::fidl::Decoder* _decoder, WithErrorSyntax_ErrorAsEnum_Response* value, size_t _offset);
+ zx_status_t Clone(WithErrorSyntax_ErrorAsEnum_Response* result) const;
+};
+
+bool operator==(const WithErrorSyntax_ErrorAsEnum_Response& _lhs, const WithErrorSyntax_ErrorAsEnum_Response& _rhs);
+inline bool operator!=(const WithErrorSyntax_ErrorAsEnum_Response& _lhs, const WithErrorSyntax_ErrorAsEnum_Response& _rhs) {
+ return !(_lhs == _rhs);
+}
+
+inline zx_status_t Clone(const ::test::name::WithErrorSyntax_ErrorAsEnum_Response& _value,
+ ::test::name::WithErrorSyntax_ErrorAsEnum_Response* _result) {
+ return _value.Clone(_result);
+}
+
+using WithErrorSyntax_ErrorAsEnum_ResponsePtr = ::std::unique_ptr<WithErrorSyntax_ErrorAsEnum_Response>;
#ifdef __Fuchsia__
class KitchenSink {
@@ -469,7 +618,204 @@ class WithAndWithoutRequestResponse_SyncProxy : public WithAndWithoutRequestResp
friend class ::fidl::SynchronousInterfacePtr<WithAndWithoutRequestResponse>;
};
#endif // __Fuchsia__
+
+class WithErrorSyntax_ErrorAsEnum_Result {
+ public:
+ WithErrorSyntax_ErrorAsEnum_Result();
+ ~WithErrorSyntax_ErrorAsEnum_Result();
+
+ WithErrorSyntax_ErrorAsEnum_Result(WithErrorSyntax_ErrorAsEnum_Result&&);
+ WithErrorSyntax_ErrorAsEnum_Result& operator=(WithErrorSyntax_ErrorAsEnum_Result&&);
+
+ enum class Tag : fidl_union_tag_t {
+ kResponse = 0,
+ kErr = 1,
+ Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
+ };
+
+ static inline ::std::unique_ptr<WithErrorSyntax_ErrorAsEnum_Result> New() { return ::std::make_unique<WithErrorSyntax_ErrorAsEnum_Result>(); }
+
+ void Encode(::fidl::Encoder* _encoder, size_t _offset);
+ static void Decode(::fidl::Decoder* _decoder, WithErrorSyntax_ErrorAsEnum_Result* _value, size_t _offset);
+ zx_status_t Clone(WithErrorSyntax_ErrorAsEnum_Result* result) const;
+
+ bool has_invalid_tag() const { return Which() == Tag::Invalid; }
+
+ bool is_response() const { return Which() == Tag(0); }
+
+ WithErrorSyntax_ErrorAsEnum_Response& response() {
+ if (!is_response()) {
+ value_.emplace<0 + 1>();
+ }
+ return value_.template get<0 + 1>();
+ }
+
+ const WithErrorSyntax_ErrorAsEnum_Response& response() const { return value_.template get<0 + 1>(); }
+ void set_response(WithErrorSyntax_ErrorAsEnum_Response value);
+
+ bool is_err() const { return Which() == Tag(1); }
+
+ ErrorEnun& err() {
+ if (!is_err()) {
+ value_.emplace<1 + 1>();
+ }
+ return value_.template get<1 + 1>();
+ }
+
+ const ErrorEnun& err() const { return value_.template get<1 + 1>(); }
+ void set_err(ErrorEnun value);
+
+ Tag Which() const {
+ size_t index = value_.index();
+ if (index == 0) {
+ return Tag::Invalid;
+ } else {
+ return Tag(index - 1);
+ }
+ }
+
+ private:
+ friend bool operator==(const WithErrorSyntax_ErrorAsEnum_Result& _lhs, const WithErrorSyntax_ErrorAsEnum_Result& _rhs);
+
+ using Variant = fit::internal::variant<fit::internal::monostate, WithErrorSyntax_ErrorAsEnum_Response, ErrorEnun>;
+ Variant value_;
+};
+
+bool operator==(const WithErrorSyntax_ErrorAsEnum_Result& _lhs, const WithErrorSyntax_ErrorAsEnum_Result& _rhs);
+inline bool operator!=(const WithErrorSyntax_ErrorAsEnum_Result& _lhs, const WithErrorSyntax_ErrorAsEnum_Result& _rhs) {
+ return !(_lhs == _rhs);
+}
+
+inline zx_status_t Clone(const ::test::name::WithErrorSyntax_ErrorAsEnum_Result& value,
+ ::test::name::WithErrorSyntax_ErrorAsEnum_Result* result) {
+ return value.Clone(result);
+}
+
+using WithErrorSyntax_ErrorAsEnum_ResultPtr = ::std::unique_ptr<WithErrorSyntax_ErrorAsEnum_Result>;
+#ifdef __Fuchsia__
+
+class WithErrorSyntax {
+ public:
+ using Proxy_ = WithErrorSyntax_Proxy;
+ using Stub_ = WithErrorSyntax_Stub;
+ using EventSender_ = WithErrorSyntax_EventSender;
+ using Sync_ = WithErrorSyntax_Sync;
+ virtual ~WithErrorSyntax();
+ using ErrorAsPrimitiveCallback =
+ fit::function<void(WithErrorSyntax_ErrorAsPrimitive_Result)>;
+
+ virtual void ErrorAsPrimitive(ErrorAsPrimitiveCallback callback) = 0;
+ using ErrorAsEnumCallback =
+ fit::function<void(WithErrorSyntax_ErrorAsEnum_Result)>;
+
+ virtual void ErrorAsEnum(ErrorAsEnumCallback callback) = 0;
+};
+
+class WithErrorSyntax_EventSender {
+ public:
+ virtual ~WithErrorSyntax_EventSender();
+};
+
+class WithErrorSyntax_Sync {
+ public:
+ using Proxy_ = WithErrorSyntax_SyncProxy;
+ virtual ~WithErrorSyntax_Sync();
+ virtual zx_status_t ErrorAsPrimitive(WithErrorSyntax_ErrorAsPrimitive_Result* out_result) = 0;
+ virtual zx_status_t ErrorAsEnum(WithErrorSyntax_ErrorAsEnum_Result* out_result) = 0;
+};
+
+class WithErrorSyntax_Proxy : public ::fidl::internal::Proxy, public WithErrorSyntax {
+ public:
+ explicit WithErrorSyntax_Proxy(::fidl::internal::ProxyController* controller);
+ ~WithErrorSyntax_Proxy() override;
+
+ zx_status_t Dispatch_(::fidl::Message message) override;
+ void ErrorAsPrimitive(ErrorAsPrimitiveCallback callback) override;
+ void ErrorAsEnum(ErrorAsEnumCallback callback) override;
+
+ private:
+ WithErrorSyntax_Proxy(const WithErrorSyntax_Proxy&) = delete;
+ WithErrorSyntax_Proxy& operator=(const WithErrorSyntax_Proxy&) = delete;
+
+ ::fidl::internal::ProxyController* controller_;
+};
+
+class WithErrorSyntax_Stub : public ::fidl::internal::Stub, public WithErrorSyntax_EventSender {
+ public:
+ typedef class ::test::name::WithErrorSyntax WithErrorSyntax_clazz;
+ explicit WithErrorSyntax_Stub(WithErrorSyntax_clazz* impl);
+ ~WithErrorSyntax_Stub() override;
+
+ zx_status_t Dispatch_(::fidl::Message message,
+ ::fidl::internal::PendingResponse response) override;
+
+ private:
+ WithErrorSyntax_clazz* impl_;
+};
+
+class WithErrorSyntax_SyncProxy : public WithErrorSyntax_Sync {
+ public:
+ explicit WithErrorSyntax_SyncProxy(::zx::channel channel);
+ ~WithErrorSyntax_SyncProxy() override;
+ zx_status_t ErrorAsPrimitive(WithErrorSyntax_ErrorAsPrimitive_Result* out_result) override;
+ zx_status_t ErrorAsEnum(WithErrorSyntax_ErrorAsEnum_Result* out_result) override;
+
+ private:
+ ::fidl::internal::SynchronousProxy proxy_;
+ friend class ::fidl::SynchronousInterfacePtr<WithErrorSyntax>;
+};
+#endif // __Fuchsia__
} // namespace name
} // namespace test
namespace fidl {
-} // namespace fidl
+
+template <>
+struct CodingTraits<::test::name::WithErrorSyntax_ErrorAsPrimitive_Response>
+ : public EncodableCodingTraits<::test::name::WithErrorSyntax_ErrorAsPrimitive_Response, 1> {};
+
+inline zx_status_t Clone(const ::test::name::WithErrorSyntax_ErrorAsPrimitive_Response& value,
+ ::test::name::WithErrorSyntax_ErrorAsPrimitive_Response* result) {
+ return ::test::name::Clone(value, result);
+}
+template <>
+struct CodingTraits<::test::name::WithErrorSyntax_ErrorAsPrimitive_Result>
+ : public EncodableCodingTraits<::test::name::WithErrorSyntax_ErrorAsPrimitive_Result, 8> {};
+
+inline zx_status_t Clone(const ::test::name::WithErrorSyntax_ErrorAsPrimitive_Result& value,
+ ::test::name::WithErrorSyntax_ErrorAsPrimitive_Result* result) {
+ return ::test::name::Clone(value, result);
+}
+template <>
+struct CodingTraits<::test::name::WithErrorSyntax_ErrorAsEnum_Response>
+ : public EncodableCodingTraits<::test::name::WithErrorSyntax_ErrorAsEnum_Response, 1> {};
+
+inline zx_status_t Clone(const ::test::name::WithErrorSyntax_ErrorAsEnum_Response& value,
+ ::test::name::WithErrorSyntax_ErrorAsEnum_Response* result) {
+ return ::test::name::Clone(value, result);
+}
+template <>
+struct CodingTraits<::test::name::ErrorEnun> {
+ static constexpr size_t encoded_size = sizeof(::test::name::ErrorEnun);
+ static void Encode(Encoder* encoder, ::test::name::ErrorEnun* value, size_t offset) {
+ uint32_t underlying = static_cast<uint32_t>(*value);
+ ::fidl::Encode(encoder, &underlying, offset);
+ }
+ static void Decode(Decoder* decoder, ::test::name::ErrorEnun* value, size_t offset) {
+ uint32_t underlying = {};
+ ::fidl::Decode(decoder, &underlying, offset);
+ *value = static_cast<::test::name::ErrorEnun>(underlying);
+ }
+};
+
+inline zx_status_t Clone(::test::name::ErrorEnun value,
+ ::test::name::ErrorEnun* result) {
+ return ::test::name::Clone(value, result);
+}
+template <>
+struct CodingTraits<::test::name::WithErrorSyntax_ErrorAsEnum_Result>
+ : public EncodableCodingTraits<::test::name::WithErrorSyntax_ErrorAsEnum_Result, 8> {};
+
+inline zx_status_t Clone(const ::test::name::WithErrorSyntax_ErrorAsEnum_Result& value,
+ ::test::name::WithErrorSyntax_ErrorAsEnum_Result* result) {
+ return ::test::name::Clone(value, result);
+}} // namespace fidl
diff --git a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.llcpp.cc.golden b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.llcpp.cc.golden
index 9fd5a73a1fc78afb18e44fb4a837cc62d075246c..6773e88b3a52ae0fecfbf88aef664cbdcc7a6b67 100644
--- a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.llcpp.cc.golden
+++ b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.llcpp.cc.golden
@@ -6,6 +6,30 @@
namespace test {
namespace name {
+::test::name::WithErrorSyntax_ErrorAsPrimitive_Result::WithErrorSyntax_ErrorAsPrimitive_Result() {
+ memset(this, 0, sizeof(WithErrorSyntax_ErrorAsPrimitive_Result));
+ tag_ = Tag::Invalid;
+}
+
+::test::name::WithErrorSyntax_ErrorAsPrimitive_Result::~WithErrorSyntax_ErrorAsPrimitive_Result() {
+ Destroy();
+}
+
+void ::test::name::WithErrorSyntax_ErrorAsPrimitive_Result::Destroy() {
+ switch (which()) {
+ case Tag::kResponse:
+ response_.~WithErrorSyntax_ErrorAsPrimitive_Response();
+ default:
+ break;
+ }
+}
+
+void ::test::name::WithErrorSyntax_ErrorAsPrimitive_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(offsetof(::test::name::WithErrorSyntax_ErrorAsPrimitive_Result, response_) == 4);
+ static_assert(offsetof(::test::name::WithErrorSyntax_ErrorAsPrimitive_Result, err_) == 4);
+ static_assert(sizeof(::test::name::WithErrorSyntax_ErrorAsPrimitive_Result) == ::test::name::WithErrorSyntax_ErrorAsPrimitive_Result::PrimarySize);
+}
+
namespace {
[[maybe_unused]]
@@ -1519,5 +1543,302 @@ zx_status_t WithAndWithoutRequestResponse::SendOnWithResponseEvent(::zx::unowned
}
+::test::name::WithErrorSyntax_ErrorAsEnum_Result::WithErrorSyntax_ErrorAsEnum_Result() {
+ memset(this, 0, sizeof(WithErrorSyntax_ErrorAsEnum_Result));
+ tag_ = Tag::Invalid;
+}
+
+::test::name::WithErrorSyntax_ErrorAsEnum_Result::~WithErrorSyntax_ErrorAsEnum_Result() {
+ Destroy();
+}
+
+void ::test::name::WithErrorSyntax_ErrorAsEnum_Result::Destroy() {
+ switch (which()) {
+ case Tag::kResponse:
+ response_.~WithErrorSyntax_ErrorAsEnum_Response();
+ case Tag::kErr:
+ err_.~ErrorEnun();
+ default:
+ break;
+ }
+}
+
+void ::test::name::WithErrorSyntax_ErrorAsEnum_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(offsetof(::test::name::WithErrorSyntax_ErrorAsEnum_Result, response_) == 4);
+ static_assert(offsetof(::test::name::WithErrorSyntax_ErrorAsEnum_Result, err_) == 4);
+ static_assert(sizeof(::test::name::WithErrorSyntax_ErrorAsEnum_Result) == ::test::name::WithErrorSyntax_ErrorAsEnum_Result::PrimarySize);
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint32_t kWithErrorSyntax_ErrorAsPrimitive_Ordinal = 2069369145u;
+[[maybe_unused]]
+constexpr uint32_t kWithErrorSyntax_ErrorAsEnum_Ordinal = 1284890143u;
+
+} // namespace
+
+zx_status_t WithErrorSyntax::SyncClient::ErrorAsPrimitive(WithErrorSyntax_ErrorAsPrimitive_Result* out_result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ErrorAsPrimitiveRequest>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _request = *reinterpret_cast<ErrorAsPrimitiveRequest*>(_write_bytes);
+ _request._hdr.ordinal = kWithErrorSyntax_ErrorAsPrimitive_Ordinal;
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ErrorAsPrimitiveRequest));
+ ::fidl::DecodedMessage<ErrorAsPrimitiveRequest> _decoded_request(std::move(_request_bytes));
+ auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+ if (_encode_request_result.status != ZX_OK) {
+ return _encode_request_result.status;
+ }
+
+ constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<ErrorAsPrimitiveResponse>();
+ FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+ ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+ auto _call_result = ::fidl::Call<ErrorAsPrimitiveRequest, ErrorAsPrimitiveResponse>(
+ this->channel_, std::move(_encode_request_result.message), std::move(_response_bytes));
+ if (_call_result.status != ZX_OK) {
+ return _call_result.status;
+ }
+ auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+ if (_decode_result.status != ZX_OK) {
+ return _decode_result.status;
+ }
+ auto& _response = *_decode_result.message.message();
+ *out_result = std::move(_response.result);
+ return ZX_OK;
+}
+
+zx_status_t WithErrorSyntax::SyncClient::ErrorAsPrimitive(::fidl::BytePart _response_buffer, WithErrorSyntax_ErrorAsPrimitive_Result* out_result) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(ErrorAsPrimitiveRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ auto& _request = *reinterpret_cast<ErrorAsPrimitiveRequest*>(_request_buffer.data());
+ _request._hdr.ordinal = kWithErrorSyntax_ErrorAsPrimitive_Ordinal;
+ _request_buffer.set_actual(sizeof(ErrorAsPrimitiveRequest));
+ ::fidl::DecodedMessage<ErrorAsPrimitiveRequest> _decoded_request(std::move(_request_buffer));
+ auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+ if (_encode_request_result.status != ZX_OK) {
+ return _encode_request_result.status;
+ }
+ auto _call_result = ::fidl::Call<ErrorAsPrimitiveRequest, ErrorAsPrimitiveResponse>(
+ this->channel_, std::move(_encode_request_result.message), std::move(_response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return _call_result.status;
+ }
+ auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+ if (_decode_result.status != ZX_OK) {
+ return _decode_result.status;
+ }
+ auto& _response = *_decode_result.message.message();
+ *out_result = std::move(_response.result);
+ return ZX_OK;
+}
+
+::fidl::DecodeResult<WithErrorSyntax::ErrorAsPrimitiveResponse> WithErrorSyntax::SyncClient::ErrorAsPrimitive(::fidl::BytePart response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(ErrorAsPrimitiveRequest)] = {};
+ constexpr uint32_t _write_num_bytes = sizeof(ErrorAsPrimitiveRequest);
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+ ::fidl::DecodedMessage<ErrorAsPrimitiveRequest> params(std::move(_request_buffer));
+ params.message()->_hdr = {};
+ params.message()->_hdr.ordinal = kWithErrorSyntax_ErrorAsPrimitive_Ordinal;
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<WithErrorSyntax::ErrorAsPrimitiveResponse>(
+ _encode_request_result.status,
+ _encode_request_result.error,
+ ::fidl::DecodedMessage<WithErrorSyntax::ErrorAsPrimitiveResponse>());
+ }
+ auto _call_result = ::fidl::Call<ErrorAsPrimitiveRequest, ErrorAsPrimitiveResponse>(
+ this->channel_, std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<WithErrorSyntax::ErrorAsPrimitiveResponse>(
+ _call_result.status,
+ _call_result.error,
+ ::fidl::DecodedMessage<WithErrorSyntax::ErrorAsPrimitiveResponse>());
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t WithErrorSyntax::SyncClient::ErrorAsEnum(WithErrorSyntax_ErrorAsEnum_Result* out_result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ErrorAsEnumRequest>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _request = *reinterpret_cast<ErrorAsEnumRequest*>(_write_bytes);
+ _request._hdr.ordinal = kWithErrorSyntax_ErrorAsEnum_Ordinal;
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ErrorAsEnumRequest));
+ ::fidl::DecodedMessage<ErrorAsEnumRequest> _decoded_request(std::move(_request_bytes));
+ auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+ if (_encode_request_result.status != ZX_OK) {
+ return _encode_request_result.status;
+ }
+
+ constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<ErrorAsEnumResponse>();
+ FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+ ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+ auto _call_result = ::fidl::Call<ErrorAsEnumRequest, ErrorAsEnumResponse>(
+ this->channel_, std::move(_encode_request_result.message), std::move(_response_bytes));
+ if (_call_result.status != ZX_OK) {
+ return _call_result.status;
+ }
+ auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+ if (_decode_result.status != ZX_OK) {
+ return _decode_result.status;
+ }
+ auto& _response = *_decode_result.message.message();
+ *out_result = std::move(_response.result);
+ return ZX_OK;
+}
+
+zx_status_t WithErrorSyntax::SyncClient::ErrorAsEnum(::fidl::BytePart _response_buffer, WithErrorSyntax_ErrorAsEnum_Result* out_result) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(ErrorAsEnumRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ auto& _request = *reinterpret_cast<ErrorAsEnumRequest*>(_request_buffer.data());
+ _request._hdr.ordinal = kWithErrorSyntax_ErrorAsEnum_Ordinal;
+ _request_buffer.set_actual(sizeof(ErrorAsEnumRequest));
+ ::fidl::DecodedMessage<ErrorAsEnumRequest> _decoded_request(std::move(_request_buffer));
+ auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+ if (_encode_request_result.status != ZX_OK) {
+ return _encode_request_result.status;
+ }
+ auto _call_result = ::fidl::Call<ErrorAsEnumRequest, ErrorAsEnumResponse>(
+ this->channel_, std::move(_encode_request_result.message), std::move(_response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return _call_result.status;
+ }
+ auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+ if (_decode_result.status != ZX_OK) {
+ return _decode_result.status;
+ }
+ auto& _response = *_decode_result.message.message();
+ *out_result = std::move(_response.result);
+ return ZX_OK;
+}
+
+::fidl::DecodeResult<WithErrorSyntax::ErrorAsEnumResponse> WithErrorSyntax::SyncClient::ErrorAsEnum(::fidl::BytePart response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(ErrorAsEnumRequest)] = {};
+ constexpr uint32_t _write_num_bytes = sizeof(ErrorAsEnumRequest);
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+ ::fidl::DecodedMessage<ErrorAsEnumRequest> params(std::move(_request_buffer));
+ params.message()->_hdr = {};
+ params.message()->_hdr.ordinal = kWithErrorSyntax_ErrorAsEnum_Ordinal;
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<WithErrorSyntax::ErrorAsEnumResponse>(
+ _encode_request_result.status,
+ _encode_request_result.error,
+ ::fidl::DecodedMessage<WithErrorSyntax::ErrorAsEnumResponse>());
+ }
+ auto _call_result = ::fidl::Call<ErrorAsEnumRequest, ErrorAsEnumResponse>(
+ this->channel_, std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<WithErrorSyntax::ErrorAsEnumResponse>(
+ _call_result.status,
+ _call_result.error,
+ ::fidl::DecodedMessage<WithErrorSyntax::ErrorAsEnumResponse>());
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool WithErrorSyntax::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ switch (hdr->ordinal) {
+ case kWithErrorSyntax_ErrorAsPrimitive_Ordinal: {
+ auto result = ::fidl::DecodeAs<ErrorAsPrimitiveRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->ErrorAsPrimitive(
+ Interface::ErrorAsPrimitiveCompleter::Sync(txn));
+ return true;
+ }
+ case kWithErrorSyntax_ErrorAsEnum_Ordinal: {
+ auto result = ::fidl::DecodeAs<ErrorAsEnumRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->ErrorAsEnum(
+ Interface::ErrorAsEnumCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool WithErrorSyntax::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void WithErrorSyntax::Interface::ErrorAsPrimitiveCompleterBase::Reply(WithErrorSyntax_ErrorAsPrimitive_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ErrorAsPrimitiveResponse>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ErrorAsPrimitiveResponse*>(_write_bytes);
+ _response._hdr.ordinal = kWithErrorSyntax_ErrorAsPrimitive_Ordinal;
+ _response.result = std::move(result);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ErrorAsPrimitiveResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ErrorAsPrimitiveResponse>(std::move(_response_bytes)));
+}
+
+void WithErrorSyntax::Interface::ErrorAsPrimitiveCompleterBase::Reply(::fidl::BytePart _buffer, WithErrorSyntax_ErrorAsPrimitive_Result result) {
+ if (_buffer.capacity() < ErrorAsPrimitiveResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ErrorAsPrimitiveResponse*>(_buffer.data());
+ _response._hdr.ordinal = kWithErrorSyntax_ErrorAsPrimitive_Ordinal;
+ _response.result = std::move(result);
+ _buffer.set_actual(sizeof(ErrorAsPrimitiveResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ErrorAsPrimitiveResponse>(std::move(_buffer)));
+}
+
+void WithErrorSyntax::Interface::ErrorAsPrimitiveCompleterBase::Reply(::fidl::DecodedMessage<ErrorAsPrimitiveResponse> params) {
+ params.message()->_hdr = {};
+ params.message()->_hdr.ordinal = kWithErrorSyntax_ErrorAsPrimitive_Ordinal;
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void WithErrorSyntax::Interface::ErrorAsEnumCompleterBase::Reply(WithErrorSyntax_ErrorAsEnum_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ErrorAsEnumResponse>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ErrorAsEnumResponse*>(_write_bytes);
+ _response._hdr.ordinal = kWithErrorSyntax_ErrorAsEnum_Ordinal;
+ _response.result = std::move(result);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ErrorAsEnumResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ErrorAsEnumResponse>(std::move(_response_bytes)));
+}
+
+void WithErrorSyntax::Interface::ErrorAsEnumCompleterBase::Reply(::fidl::BytePart _buffer, WithErrorSyntax_ErrorAsEnum_Result result) {
+ if (_buffer.capacity() < ErrorAsEnumResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ErrorAsEnumResponse*>(_buffer.data());
+ _response._hdr.ordinal = kWithErrorSyntax_ErrorAsEnum_Ordinal;
+ _response.result = std::move(result);
+ _buffer.set_actual(sizeof(ErrorAsEnumResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ErrorAsEnumResponse>(std::move(_buffer)));
+}
+
+void WithErrorSyntax::Interface::ErrorAsEnumCompleterBase::Reply(::fidl::DecodedMessage<ErrorAsEnumResponse> params) {
+ params.message()->_hdr = {};
+ params.message()->_hdr.ordinal = kWithErrorSyntax_ErrorAsEnum_Ordinal;
+ CompleterBase::SendReply(std::move(params));
+}
+
+
} // namespace name
} // namespace test
diff --git a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.llcpp.h.golden b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.llcpp.h.golden
index 1464b95ac1fb2c1b45d19e4c171fdbc4d7703dac..a915085ba5a3aff985cec5100fa2bde33bfe69b7 100644
--- a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.llcpp.h.golden
+++ b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.llcpp.h.golden
@@ -15,11 +15,110 @@
namespace test {
namespace name {
+struct WithErrorSyntax_ErrorAsPrimitive_Response;
+struct WithErrorSyntax_ErrorAsPrimitive_Result;
+struct WithErrorSyntax_ErrorAsEnum_Response;
class KitchenSink;
class ChannelProtocol;
class SocketControlProtocol;
class OvernetInternalProtocol;
class WithAndWithoutRequestResponse;
+enum class ErrorEnun : uint32_t {
+ ERR_FOO = 1,
+ ERR_BAR = 2,
+};
+
+
+struct WithErrorSyntax_ErrorAsEnum_Result;
+class WithErrorSyntax;
+
+
+
+struct WithErrorSyntax_ErrorAsPrimitive_Response {
+ static constexpr const fidl_type_t* Type = nullptr;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+
+ uint8_t __reserved = 0;
+};
+
+extern "C" const fidl_type_t test_name_WithErrorSyntax_ErrorAsPrimitive_ResultTable;
+
+struct WithErrorSyntax_ErrorAsPrimitive_Result {
+ enum class Tag : fidl_union_tag_t {
+ kResponse = 0,
+ kErr = 1,
+ Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
+ };
+
+ WithErrorSyntax_ErrorAsPrimitive_Result();
+ ~WithErrorSyntax_ErrorAsPrimitive_Result();
+
+ bool has_invalid_tag() const { return tag_ == Tag::Invalid; }
+
+ bool is_response() const { return tag_ == Tag::kResponse; }
+
+ WithErrorSyntax_ErrorAsPrimitive_Response& mutable_response() {
+ if (which() != Tag::kResponse) {
+ Destroy();
+ }
+ tag_ = Tag::kResponse;
+ return response_;
+ }
+
+ void set_response(WithErrorSyntax_ErrorAsPrimitive_Response const & v) {
+ mutable_response() = v;
+ }
+
+ WithErrorSyntax_ErrorAsPrimitive_Response const & response() const { return response_; }
+
+ bool is_err() const { return tag_ == Tag::kErr; }
+
+ uint32_t& mutable_err() {
+ if (which() != Tag::kErr) {
+ Destroy();
+ }
+ tag_ = Tag::kErr;
+ return err_;
+ }
+
+ void set_err(uint32_t const & v) {
+ mutable_err() = v;
+ }
+
+ uint32_t const & err() const { return err_; }
+
+ Tag which() const { return tag_; }
+
+ static constexpr const fidl_type_t* Type = &test_name_WithErrorSyntax_ErrorAsPrimitive_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+
+ private:
+ void Destroy();
+ static void SizeAndOffsetAssertionHelper();
+ Tag tag_;
+ union {
+ WithErrorSyntax_ErrorAsPrimitive_Response response_;
+ uint32_t err_;
+ };
+};
+
+
+
+struct WithErrorSyntax_ErrorAsEnum_Response {
+ static constexpr const fidl_type_t* Type = nullptr;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+
+ uint8_t __reserved = 0;
+};
class KitchenSink final {
@@ -781,11 +880,204 @@ class WithAndWithoutRequestResponse final {
};
+extern "C" const fidl_type_t test_name_WithErrorSyntax_ErrorAsEnum_ResultTable;
+
+struct WithErrorSyntax_ErrorAsEnum_Result {
+ enum class Tag : fidl_union_tag_t {
+ kResponse = 0,
+ kErr = 1,
+ Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
+ };
+
+ WithErrorSyntax_ErrorAsEnum_Result();
+ ~WithErrorSyntax_ErrorAsEnum_Result();
+
+ bool has_invalid_tag() const { return tag_ == Tag::Invalid; }
+
+ bool is_response() const { return tag_ == Tag::kResponse; }
+
+ WithErrorSyntax_ErrorAsEnum_Response& mutable_response() {
+ if (which() != Tag::kResponse) {
+ Destroy();
+ }
+ tag_ = Tag::kResponse;
+ return response_;
+ }
+
+ void set_response(WithErrorSyntax_ErrorAsEnum_Response const & v) {
+ mutable_response() = v;
+ }
+
+ WithErrorSyntax_ErrorAsEnum_Response const & response() const { return response_; }
+
+ bool is_err() const { return tag_ == Tag::kErr; }
+
+ ErrorEnun& mutable_err() {
+ if (which() != Tag::kErr) {
+ Destroy();
+ }
+ tag_ = Tag::kErr;
+ return err_;
+ }
+
+ void set_err(ErrorEnun const & v) {
+ mutable_err() = v;
+ }
+
+ ErrorEnun const & err() const { return err_; }
+
+ Tag which() const { return tag_; }
+
+ static constexpr const fidl_type_t* Type = &test_name_WithErrorSyntax_ErrorAsEnum_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+
+ private:
+ void Destroy();
+ static void SizeAndOffsetAssertionHelper();
+ Tag tag_;
+ union {
+ WithErrorSyntax_ErrorAsEnum_Response response_;
+ ErrorEnun err_;
+ };
+};
+
+
+class WithErrorSyntax final {
+ public:
+
+ struct ErrorAsPrimitiveResponse {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ WithErrorSyntax_ErrorAsPrimitive_Result result;
+
+ static constexpr const fidl_type_t* Type = nullptr;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ };
+ using ErrorAsPrimitiveRequest = ::fidl::AnyZeroArgMessage;
+
+ struct ErrorAsEnumResponse {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ WithErrorSyntax_ErrorAsEnum_Result result;
+
+ static constexpr const fidl_type_t* Type = nullptr;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ };
+ using ErrorAsEnumRequest = ::fidl::AnyZeroArgMessage;
+
+
+ class SyncClient final {
+ public:
+ SyncClient(::zx::channel channel) : channel_(std::move(channel)) {}
+
+ ~SyncClient() {}
+
+ zx_status_t ErrorAsPrimitive(WithErrorSyntax_ErrorAsPrimitive_Result* out_result);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ zx_status_t ErrorAsPrimitive(::fidl::BytePart _response_buffer, WithErrorSyntax_ErrorAsPrimitive_Result* out_result);
+
+ // Messages are encoded and decoded in-place.
+ ::fidl::DecodeResult<ErrorAsPrimitiveResponse> ErrorAsPrimitive(::fidl::BytePart response_buffer);
+
+ zx_status_t ErrorAsEnum(WithErrorSyntax_ErrorAsEnum_Result* out_result);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ zx_status_t ErrorAsEnum(::fidl::BytePart _response_buffer, WithErrorSyntax_ErrorAsEnum_Result* out_result);
+
+ // Messages are encoded and decoded in-place.
+ ::fidl::DecodeResult<ErrorAsEnumResponse> ErrorAsEnum(::fidl::BytePart response_buffer);
+
+ private:
+ ::zx::channel channel_;
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = WithErrorSyntax;
+ using _Base = ::fidl::CompleterBase;
+
+ class ErrorAsPrimitiveCompleterBase : public _Base {
+ public:
+ void Reply(WithErrorSyntax_ErrorAsPrimitive_Result result);
+ void Reply(::fidl::BytePart _buffer, WithErrorSyntax_ErrorAsPrimitive_Result result);
+ void Reply(::fidl::DecodedMessage<ErrorAsPrimitiveResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ErrorAsPrimitiveCompleter = ::fidl::Completer<ErrorAsPrimitiveCompleterBase>;
+
+ virtual void ErrorAsPrimitive(ErrorAsPrimitiveCompleter::Sync _completer) = 0;
+
+ class ErrorAsEnumCompleterBase : public _Base {
+ public:
+ void Reply(WithErrorSyntax_ErrorAsEnum_Result result);
+ void Reply(::fidl::BytePart _buffer, WithErrorSyntax_ErrorAsEnum_Result result);
+ void Reply(::fidl::DecodedMessage<ErrorAsEnumResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ErrorAsEnumCompleter = ::fidl::Completer<ErrorAsEnumCompleterBase>;
+
+ virtual void ErrorAsEnum(ErrorAsEnumCompleter::Sync _completer) = 0;
+
+ };
+
+ // Attempts to dispatch the incoming message to a handler function in the server implementation.
+ // If there is no matching handler, it returns false, leaving the message and transaction intact.
+ // In all other cases, it consumes the message and returns true.
+ // It is possible to chain multiple TryDispatch functions in this manner.
+ static bool TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn);
+
+ // Dispatches the incoming message to one of the handlers functions in the interface.
+ // If there is no matching handler, it closes all the handles in |msg| and closes the channel with
+ // a |ZX_ERR_NOT_SUPPORTED| epitaph, before returning false. The message should then be discarded.
+ static bool Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn);
+
+ // Same as |Dispatch|, but takes a |void*| instead of |Interface*|. Only used with |fidl::Bind|
+ // to reduce template expansion.
+ // Do not call this method manually. Use |Dispatch| instead.
+ static bool TypeErasedDispatch(void* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ return Dispatch(static_cast<Interface*>(impl), msg, txn);
+ }
+
+};
+
} // namespace name
} // namespace test
namespace fidl {
+template <>
+struct IsFidlType<::test::name::WithErrorSyntax_ErrorAsPrimitive_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::test::name::WithErrorSyntax_ErrorAsPrimitive_Response>);
+static_assert(offsetof(::test::name::WithErrorSyntax_ErrorAsPrimitive_Response, __reserved) == 0);
+static_assert(sizeof(::test::name::WithErrorSyntax_ErrorAsPrimitive_Response) == ::test::name::WithErrorSyntax_ErrorAsPrimitive_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::test::name::WithErrorSyntax_ErrorAsPrimitive_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::test::name::WithErrorSyntax_ErrorAsPrimitive_Result>);
+
+template <>
+struct IsFidlType<::test::name::WithErrorSyntax_ErrorAsEnum_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::test::name::WithErrorSyntax_ErrorAsEnum_Response>);
+static_assert(offsetof(::test::name::WithErrorSyntax_ErrorAsEnum_Response, __reserved) == 0);
+static_assert(sizeof(::test::name::WithErrorSyntax_ErrorAsEnum_Response) == ::test::name::WithErrorSyntax_ErrorAsEnum_Response::PrimarySize);
+
template <>
struct IsFidlType<::test::name::KitchenSink::MethodARequest> : public std::true_type {};
template <>
@@ -974,4 +1266,24 @@ static_assert(sizeof(::test::name::WithAndWithoutRequestResponse::OnWithResponse
== ::test::name::WithAndWithoutRequestResponse::OnWithResponseResponse::PrimarySize);
static_assert(offsetof(::test::name::WithAndWithoutRequestResponse::OnWithResponseResponse, ret) == 16);
+template <>
+struct IsFidlType<::test::name::WithErrorSyntax_ErrorAsEnum_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::test::name::WithErrorSyntax_ErrorAsEnum_Result>);
+
+template <>
+struct IsFidlType<::test::name::WithErrorSyntax::ErrorAsPrimitiveResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::test::name::WithErrorSyntax::ErrorAsPrimitiveResponse> : public std::true_type {};
+static_assert(sizeof(::test::name::WithErrorSyntax::ErrorAsPrimitiveResponse)
+ == ::test::name::WithErrorSyntax::ErrorAsPrimitiveResponse::PrimarySize);
+static_assert(offsetof(::test::name::WithErrorSyntax::ErrorAsPrimitiveResponse, result) == 16);
+
+template <>
+struct IsFidlType<::test::name::WithErrorSyntax::ErrorAsEnumResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::test::name::WithErrorSyntax::ErrorAsEnumResponse> : public std::true_type {};
+static_assert(sizeof(::test::name::WithErrorSyntax::ErrorAsEnumResponse)
+ == ::test::name::WithErrorSyntax::ErrorAsEnumResponse::PrimarySize);
+static_assert(offsetof(::test::name::WithErrorSyntax::ErrorAsEnumResponse, result) == 16);
+
} // namespace fidl
diff --git a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.overnet_internal.cc.golden b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.overnet_internal.cc.golden
index fb9b26c2b45de7e013f0d193512f54c3fecddcea..7c8279bd59994870b894dfaacca1ecd41a7e7ac5 100644
--- a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.overnet_internal.cc.golden
+++ b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.overnet_internal.cc.golden
@@ -4,6 +4,9 @@
namespace test {
namespace name {
+
+
+
namespace {
@@ -264,5 +267,9 @@ void OvernetInternalProtocol_Stub::EventA(int64_t a, int64_t b) {
+
+
+
+
} // namespace name
} // namespace test
\ No newline at end of file
diff --git a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.overnet_internal.h.golden b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.overnet_internal.h.golden
index d98f9f21c56493d676d4d5071dc32036840eefd8..87d5c98a5d7fbbebc2abb23ce925334f4861b243 100644
--- a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.overnet_internal.h.golden
+++ b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.overnet_internal.h.golden
@@ -5,6 +5,9 @@
namespace test {
namespace name {
+
+
+
class KitchenSink;
@@ -26,6 +29,13 @@ class OvernetInternalProtocol_Stub;
+
+
+
+
+
+
+
@@ -117,6 +127,13 @@ class OvernetInternalProtocol_Stub : public ::overnet::FidlStream, public Overne
+
+
+
+
+
+
+
@@ -128,6 +145,10 @@ class OvernetInternalProtocol_Stub : public ::overnet::FidlStream, public Overne
+
+
+
+
diff --git a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.rs.golden b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.rs.golden
index 95d0930616e80d542735b20acbe2bdf97a13710a..d86201adbceff560524e95185d6a20d9cadffb02 100644
--- a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.rs.golden
+++ b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json.rs.golden
@@ -22,6 +22,30 @@ use fidl::{
};
+fidl_enum! {
+ ErrorEnun(u32) {
+ ErrFoo = 1,
+ ErrBar = 2,
+ }
+}
+
+
+type WithErrorSyntaxErrorAsPrimitiveResult = std::result::Result< WithErrorSyntaxErrorAsPrimitiveResponse , u32 >;
+
+
+type WithErrorSyntaxErrorAsEnumResult = std::result::Result< WithErrorSyntaxErrorAsEnumResponse , ErrorEnun >;
+
+
+
+fidl_empty_struct!(
+ WithErrorSyntaxErrorAsPrimitiveResponse
+);
+
+
+fidl_empty_struct!(
+ WithErrorSyntaxErrorAsEnumResponse
+);
+
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct WithAndWithoutRequestResponseMarker;
@@ -1431,6 +1455,748 @@ impl WithAndWithoutRequestResponseWithRequestWithResponseResponder {
}
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct WithErrorSyntaxMarker;
+
+impl fidl::endpoints::ServiceMarker for WithErrorSyntaxMarker {
+ type Proxy = WithErrorSyntaxProxy;
+ type RequestStream = WithErrorSyntaxRequestStream;
+ const NAME: &'static str = "";
+}
+
+pub trait WithErrorSyntaxProxyInterface: Send + Sync {
+ type ErrorAsPrimitiveResponseFut: futures::Future<Output = Result<(WithErrorSyntaxErrorAsPrimitiveResult), fidl::Error>> + Send;
+ fn error_as_primitive(&self,
+ )-> Self::ErrorAsPrimitiveResponseFut;
+ type ErrorAsEnumResponseFut: futures::Future<Output = Result<(WithErrorSyntaxErrorAsEnumResult), fidl::Error>> + Send;
+ fn error_as_enum(&self,
+ )-> Self::ErrorAsEnumResponseFut;
+}
+
+#[derive(Debug)]
+pub struct WithErrorSyntaxSynchronousProxy {
+ client: fidl::client::sync::Client,
+}
+
+impl WithErrorSyntaxSynchronousProxy {
+ pub fn new(channel: zx::Channel) -> Self {
+ Self { client: fidl::client::sync::Client::new(channel) }
+ }
+
+ pub fn into_channel(self) -> zx::Channel {
+ self.client.into_channel()
+ }
+ pub fn error_as_primitive(&mut self,___deadline: zx::Time,) -> Result<(WithErrorSyntaxErrorAsPrimitiveResult), fidl::Error> {self.client.send_query(&mut (),
+ 2069369145,
+ ___deadline,
+ )}
+ pub fn error_as_enum(&mut self,___deadline: zx::Time,) -> Result<(WithErrorSyntaxErrorAsEnumResult), fidl::Error> {self.client.send_query(&mut (),
+ 1284890143,
+ ___deadline,
+ )}
+}
+
+#[derive(Debug, Clone)]
+pub struct WithErrorSyntaxProxy {
+ client: fidl::client::Client,
+}
+
+impl fidl::endpoints::Proxy for WithErrorSyntaxProxy {
+ type Service = WithErrorSyntaxMarker;
+ fn from_channel(inner: ::fuchsia_async::Channel) -> Self {
+ Self::new(inner)
+ }
+}
+
+impl ::std::ops::Deref for WithErrorSyntaxProxy {
+ type Target = fidl::client::Client;
+
+ fn deref(&self) -> &Self::Target {
+ &self.client
+ }
+}
+
+/// Proxy object for communicating with interface WithErrorSyntax
+impl WithErrorSyntaxProxy {
+ /// Create a new Proxy for WithErrorSyntax
+ pub fn new(channel: ::fuchsia_async::Channel) -> Self {
+ Self { client: fidl::client::Client::new(channel) }
+ }
+
+ /// Attempt to convert the Proxy back into a channel.
+ ///
+ /// This will only succeed if there are no active clones of this Proxy
+ /// and no currently-alive EventStream or response futures that came from
+ /// this Proxy.
+ pub fn into_channel(self) -> Result<::fuchsia_async::Channel, Self> {
+ self.client.into_channel().map_err(|client| Self { client })
+ }
+
+ /// Get a Stream of events from the remote end of the WithErrorSyntax interface
+ pub fn take_event_stream(&self) -> WithErrorSyntaxEventStream {
+ WithErrorSyntaxEventStream {
+ event_receiver: self.client.take_event_receiver(),
+ }
+ }
+ pub fn error_as_primitive(&self,
+ )-> fidl::client::QueryResponseFut<(WithErrorSyntaxErrorAsPrimitiveResult)> {
+ WithErrorSyntaxProxyInterface::error_as_primitive(self,
+ )
+ }
+ pub fn error_as_enum(&self,
+ )-> fidl::client::QueryResponseFut<(WithErrorSyntaxErrorAsEnumResult)> {
+ WithErrorSyntaxProxyInterface::error_as_enum(self,
+ )
+ }
+}
+
+impl WithErrorSyntaxProxyInterface for WithErrorSyntaxProxy {
+ type ErrorAsPrimitiveResponseFut = fidl::client::QueryResponseFut<(WithErrorSyntaxErrorAsPrimitiveResult)>;
+ fn error_as_primitive(&self,
+ )-> Self::ErrorAsPrimitiveResponseFut {
+ self.client.send_query(&mut (), 2069369145)
+ }
+ type ErrorAsEnumResponseFut = fidl::client::QueryResponseFut<(WithErrorSyntaxErrorAsEnumResult)>;
+ fn error_as_enum(&self,
+ )-> Self::ErrorAsEnumResponseFut {
+ self.client.send_query(&mut (), 1284890143)
+ }}
+
+pub struct WithErrorSyntaxEventStream {
+ event_receiver: fidl::client::EventReceiver,
+}
+
+impl ::std::marker::Unpin for WithErrorSyntaxEventStream {}
+
+impl futures::stream::FusedStream for WithErrorSyntaxEventStream {
+ fn is_terminated(&self) -> bool {
+ self.event_receiver.is_terminated()
+ }
+}
+
+impl futures::Stream for WithErrorSyntaxEventStream {
+ type Item = Result<WithErrorSyntaxEvent, fidl::Error>;
+
+ fn poll_next(mut self: ::std::pin::Pin<&mut Self>, lw: &futures::task::Waker)
+ -> futures::Poll<Option<Self::Item>>
+ {
+ let mut buf = match futures::ready!(
+ futures::stream::StreamExt::poll_next_unpin(&mut self.event_receiver, lw)?
+ ) {
+ Some(buf) => buf,
+ None => return futures::Poll::Ready(None),
+ };
+ let (bytes, _handles) = buf.split_mut();
+ let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
+
+ #[allow(unreachable_patterns)] // GenOrdinal and Ordinal can overlap
+ futures::Poll::Ready(Some(match tx_header.ordinal {
+ _ => Err(fidl::Error::UnknownOrdinal {
+ ordinal: tx_header.ordinal,
+ service_name: <WithErrorSyntaxMarker as fidl::endpoints::ServiceMarker>::NAME,
+ })
+ }))
+ }
+}
+
+#[derive(Debug)]
+pub enum WithErrorSyntaxEvent {
+
+
+ }
+
+pub struct WithErrorSyntaxEventSender<'a> {
+ // Some protocols don't define events which would render this channel unused.
+ #[allow(unused)]
+ channel: zx::Unowned<'a, zx::Channel>,
+}
+impl <'a> WithErrorSyntaxEventSender<'a> {
+ pub fn new(channel: zx::Unowned<'a, zx::Channel>) -> Self {
+ Self { channel }
+ }
+}
+
+#[deprecated(note = "use WithErrorSyntaxRequestStream instead")]
+pub trait WithErrorSyntax {
+ type OnOpenFut: futures::Future<Output = ()> + Send;
+ fn on_open(&mut self, control_handle: WithErrorSyntaxControlHandle) -> Self::OnOpenFut;
+ type ErrorAsPrimitiveFut: futures::Future<Output = ()> + Send;
+ fn error_as_primitive (&mut self,
+ response_chan: WithErrorSyntaxErrorAsPrimitiveResponder,
+ ) -> Self::ErrorAsPrimitiveFut;
+
+ type ErrorAsEnumFut: futures::Future<Output = ()> + Send;
+ fn error_as_enum (&mut self,
+ response_chan: WithErrorSyntaxErrorAsEnumResponder,
+ ) -> Self::ErrorAsEnumFut;
+
+
+ fn serve(mut self, channel: ::fuchsia_async::Channel)
+ -> WithErrorSyntaxServer<Self>
+ where Self: Sized
+ {
+ let inner = ::std::sync::Arc::new(fidl::ServeInner::new(channel));
+ let on_open_fut = self.on_open(
+ WithErrorSyntaxControlHandle {
+ inner: inner.clone(),
+ }
+ );
+ WithErrorSyntaxServer {
+ server: self,
+ inner: inner.clone(),
+ on_open_fut: Some(on_open_fut),error_as_primitive_futures: futures::stream::FuturesUnordered::new(),error_as_enum_futures: futures::stream::FuturesUnordered::new(),
+ }
+ }
+}
+
+pub struct WithErrorSyntaxServer<T: WithErrorSyntax> {
+ #[allow(dead_code)] // not used if no methods are present
+ server: T,
+ inner: ::std::sync::Arc<fidl::ServeInner>,
+ on_open_fut: Option<T::OnOpenFut>,error_as_primitive_futures: futures::stream::FuturesUnordered<T::ErrorAsPrimitiveFut>,error_as_enum_futures: futures::stream::FuturesUnordered<T::ErrorAsEnumFut>,
+}
+
+// Safety: only the OnOpen fut is held directly, so it's the only one that
+// is projected to, so it's the only one that needs to be Unpin for the Impl
+// struct to be Unpin.
+impl<T: WithErrorSyntax> ::std::marker::Unpin for WithErrorSyntaxServer<T>
+where T::OnOpenFut: ::std::marker::Unpin,
+{}
+
+impl<T: WithErrorSyntax> WithErrorSyntaxServer<T> {
+ pub fn control_handle(&self) -> WithErrorSyntaxControlHandle {
+ WithErrorSyntaxControlHandle {
+ inner: self.inner.clone(),
+ }
+ }
+}
+
+impl<T: WithErrorSyntax> futures::Future for WithErrorSyntaxServer<T> {
+ type Output = Result<(), fidl::Error>;
+
+ fn poll(
+ mut self: ::std::pin::Pin<&mut Self>,
+ lw: &futures::task::Waker,
+ ) -> futures::Poll<Self::Output> {
+ // safety: the only potentially !Unpin field is on_open_fut, which we make sure
+ // isn't moved below
+ let this = unsafe { ::std::pin::Pin::get_unchecked_mut(self) };
+ loop {
+ let mut made_progress_this_loop_iter = false;
+
+ if this.inner.poll_shutdown(lw) {
+ return futures::Poll::Ready(Ok(()));
+ }
+
+ unsafe {
+ // Safety: ensure that on_open isn't moved
+ let completed_on_open = if let Some(on_open_fut) = &mut this.on_open_fut {
+ match futures::Future::poll(::std::pin::Pin::new_unchecked(on_open_fut), lw) {
+ futures::Poll::Ready(()) => true,
+ futures::Poll::Pending => false,
+ }
+ } else {
+ false
+ };
+
+ if completed_on_open {
+ made_progress_this_loop_iter = true;
+ this.on_open_fut = None;
+ }
+ }match futures::stream::StreamExt::poll_next_unpin(
+ &mut this.error_as_primitive_futures, lw
+ ) {
+ futures::Poll::Ready(Some(())) => made_progress_this_loop_iter = true,
+ _ => {},
+ }match futures::stream::StreamExt::poll_next_unpin(
+ &mut this.error_as_enum_futures, lw
+ ) {
+ futures::Poll::Ready(Some(())) => made_progress_this_loop_iter = true,
+ _ => {},
+ }
+
+ let poll_done = ::fidl::encoding::with_tls_coding_bufs(|bytes, handles| {
+ match ::futures::ready!(this.inner.channel().read(bytes, handles, lw)) {
+ Ok(()) => {},
+ Err(zx::Status::PEER_CLOSED) => return futures::Poll::Ready(Ok(true)),
+ Err(e) => return futures::Poll::Ready(Err(fidl::Error::ServerRequestRead(e))),
+ }
+
+ {
+ // A message has been received from the channel
+ let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
+
+ #[allow(unreachable_patterns)] // GenOrdinal and Ordinal can overlap
+ match header.ordinal {
+ 2069369145 | 2069369145 => {
+ let mut req: () = fidl::encoding::Decodable::new_empty();
+ fidl::encoding::Decoder::decode_into(_body_bytes, handles, &mut req)?;
+ let control_handle = WithErrorSyntaxControlHandle {
+ inner: this.inner.clone(),
+ };
+ this.error_as_primitive_futures.push(
+ this.server.error_as_primitive(WithErrorSyntaxErrorAsPrimitiveResponder {
+ control_handle: ::std::mem::ManuallyDrop::new(control_handle),
+ tx_id: header.tx_id,
+ ordinal: header.ordinal,
+ })
+ );
+ ::futures::Poll::Ready(Ok(false))
+ }
+ 1284890143 | 1284890143 => {
+ let mut req: () = fidl::encoding::Decodable::new_empty();
+ fidl::encoding::Decoder::decode_into(_body_bytes, handles, &mut req)?;
+ let control_handle = WithErrorSyntaxControlHandle {
+ inner: this.inner.clone(),
+ };
+ this.error_as_enum_futures.push(
+ this.server.error_as_enum(WithErrorSyntaxErrorAsEnumResponder {
+ control_handle: ::std::mem::ManuallyDrop::new(control_handle),
+ tx_id: header.tx_id,
+ ordinal: header.ordinal,
+ })
+ );
+ ::futures::Poll::Ready(Ok(false))
+ }
+ // TODO(cramertj) handle control/fileio messages
+ _ => return futures::Poll::Ready(Err(fidl::Error::UnknownOrdinal {
+ ordinal: header.ordinal,
+ service_name: "unknown fidl", // TODO(cramertj)
+ })),
+ }
+ }
+ })?;
+
+ match poll_done {
+ ::futures::Poll::Ready(true) => return ::futures::Poll::Ready(Ok(())),
+ ::futures::Poll::Ready(false) => {},
+ ::futures::Poll::Pending if made_progress_this_loop_iter => {}, // continue
+ ::futures::Poll::Pending => return ::futures::Poll::Pending,
+ }
+ }}
+}
+
+/// A Stream of incoming requests for WithErrorSyntax
+pub struct WithErrorSyntaxRequestStream {
+ inner: ::std::sync::Arc<fidl::ServeInner>,
+ is_terminated: bool,
+}
+
+impl ::std::marker::Unpin for WithErrorSyntaxRequestStream {}
+
+impl futures::stream::FusedStream for WithErrorSyntaxRequestStream {
+ fn is_terminated(&self) -> bool {
+ self.is_terminated
+ }
+}
+
+impl fidl::endpoints::RequestStream for WithErrorSyntaxRequestStream {
+ type Service = WithErrorSyntaxMarker;
+
+ /// Consume a channel to make a WithErrorSyntaxRequestStream
+ fn from_channel(channel: ::fuchsia_async::Channel) -> Self {
+ Self {
+ inner: ::std::sync::Arc::new(fidl::ServeInner::new(channel)),
+ is_terminated: false,
+ }
+ }
+
+ /// ControlHandle for the remote connection
+ type ControlHandle = WithErrorSyntaxControlHandle;
+
+ /// ControlHandle for the remote connection
+ fn control_handle(&self) -> Self::ControlHandle {
+ WithErrorSyntaxControlHandle { inner: self.inner.clone() }
+ }
+
+ fn into_inner(self) -> (::std::sync::Arc<fidl::ServeInner>, bool) {
+ (self.inner, self.is_terminated)
+ }
+
+ fn from_inner(inner: ::std::sync::Arc<fidl::ServeInner>, is_terminated: bool)
+ -> Self
+ {
+ Self { inner, is_terminated }
+ }
+}
+
+impl futures::Stream for WithErrorSyntaxRequestStream {
+ type Item = Result<WithErrorSyntaxRequest, fidl::Error>;
+
+ fn poll_next(mut self: ::std::pin::Pin<&mut Self>, lw: &futures::task::Waker)
+ -> futures::Poll<Option<Self::Item>>
+ {
+ let this = &mut *self;
+ if this.inner.poll_shutdown(lw) {
+ this.is_terminated = true;
+ return futures::Poll::Ready(None);
+ }
+ if this.is_terminated {
+ panic!("polled WithErrorSyntaxRequestStream after completion");
+ }
+ ::fidl::encoding::with_tls_coding_bufs(|bytes, handles| {
+ match this.inner.channel().read(bytes, handles, lw) {
+ futures::Poll::Ready(Ok(())) => {},
+ futures::Poll::Pending => return futures::Poll::Pending,
+ futures::Poll::Ready(Err(zx::Status::PEER_CLOSED)) => {
+ this.is_terminated = true;
+ return futures::Poll::Ready(None)
+ },
+ futures::Poll::Ready(Err(e)) =>
+ return futures::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(e)))),
+ }
+
+ // A message has been received from the channel
+ let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
+
+ #[allow(unreachable_patterns)] // GenOrdinal and Ordinal can overlap
+ futures::Poll::Ready(Some(match header.ordinal {
+ 2069369145 | 2069369145 => {
+ let mut req: () = fidl::encoding::Decodable::new_empty();
+ fidl::encoding::Decoder::decode_into(_body_bytes, handles, &mut req)?;
+ let control_handle = WithErrorSyntaxControlHandle {
+ inner: this.inner.clone(),
+ };
+
+ Ok(WithErrorSyntaxRequest::ErrorAsPrimitive {responder:WithErrorSyntaxErrorAsPrimitiveResponder {
+ control_handle: ::std::mem::ManuallyDrop::new(control_handle),
+ tx_id: header.tx_id,
+ ordinal: header.ordinal,
+ },})
+ }
+ 1284890143 | 1284890143 => {
+ let mut req: () = fidl::encoding::Decodable::new_empty();
+ fidl::encoding::Decoder::decode_into(_body_bytes, handles, &mut req)?;
+ let control_handle = WithErrorSyntaxControlHandle {
+ inner: this.inner.clone(),
+ };
+
+ Ok(WithErrorSyntaxRequest::ErrorAsEnum {responder:WithErrorSyntaxErrorAsEnumResponder {
+ control_handle: ::std::mem::ManuallyDrop::new(control_handle),
+ tx_id: header.tx_id,
+ ordinal: header.ordinal,
+ },})
+ }
+ _ => Err(fidl::Error::UnknownOrdinal {
+ ordinal: header.ordinal,
+ service_name: <WithErrorSyntaxMarker as fidl::endpoints::ServiceMarker>::NAME,
+ }),
+ }))
+ })
+ }
+}
+pub enum WithErrorSyntaxRequest {
+ ErrorAsPrimitive {
+ responder: WithErrorSyntaxErrorAsPrimitiveResponder,},
+ ErrorAsEnum {
+ responder: WithErrorSyntaxErrorAsEnumResponder,},
+}
+
+pub struct WithErrorSyntaxEncoder;
+impl WithErrorSyntaxEncoder {
+ pub fn encode_error_as_primitive_request<'a>(
+ out_bytes: &'a mut Vec<u8>,
+ out_handles: &'a mut Vec<zx::Handle>,
+ tx_id: u32,) -> Result<(), fidl::Error> {
+ let header = fidl::encoding::TransactionHeader {
+ tx_id,flags: 0,
+ ordinal: 2069369145,
+ };
+ let mut body = ();
+ let mut msg = fidl::encoding::TransactionMessage { header, body: &mut body };
+ fidl::encoding::Encoder::encode(out_bytes, out_handles, &mut msg)?;
+ Ok(())
+ }
+ pub fn encode_error_as_primitive_response<'a>(
+ out_bytes: &'a mut Vec<u8>,
+ out_handles: &'a mut Vec<zx::Handle>,
+ tx_id: u32,mut in_result: &mut WithErrorSyntaxErrorAsPrimitiveResult,) -> Result<(), fidl::Error> {
+ let header = fidl::encoding::TransactionHeader {
+ tx_id,flags: 0,
+ ordinal: 2069369145,
+ };
+ let mut body = (in_result,);
+ let mut msg = fidl::encoding::TransactionMessage { header, body: &mut body };
+ fidl::encoding::Encoder::encode(out_bytes, out_handles, &mut msg)?;
+ Ok(())
+ }
+ pub fn encode_error_as_enum_request<'a>(
+ out_bytes: &'a mut Vec<u8>,
+ out_handles: &'a mut Vec<zx::Handle>,
+ tx_id: u32,) -> Result<(), fidl::Error> {
+ let header = fidl::encoding::TransactionHeader {
+ tx_id,flags: 0,
+ ordinal: 1284890143,
+ };
+ let mut body = ();
+ let mut msg = fidl::encoding::TransactionMessage { header, body: &mut body };
+ fidl::encoding::Encoder::encode(out_bytes, out_handles, &mut msg)?;
+ Ok(())
+ }
+ pub fn encode_error_as_enum_response<'a>(
+ out_bytes: &'a mut Vec<u8>,
+ out_handles: &'a mut Vec<zx::Handle>,
+ tx_id: u32,mut in_result: &mut WithErrorSyntaxErrorAsEnumResult,) -> Result<(), fidl::Error> {
+ let header = fidl::encoding::TransactionHeader {
+ tx_id,flags: 0,
+ ordinal: 1284890143,
+ };
+ let mut body = (in_result,);
+ let mut msg = fidl::encoding::TransactionMessage { header, body: &mut body };
+ fidl::encoding::Encoder::encode(out_bytes, out_handles, &mut msg)?;
+ Ok(())
+ }}
+
+#[deprecated(note = "use WithErrorSyntaxRequestStream instead")]
+pub struct WithErrorSyntaxImpl<
+ State,
+OnOpen: FnMut(&mut State, WithErrorSyntaxControlHandle) -> OnOpenFut,
+OnOpenFut: futures::Future<Output = ()> + Send,
+ ErrorAsPrimitive: FnMut(&mut State,WithErrorSyntaxErrorAsPrimitiveResponder) -> ErrorAsPrimitiveFut,
+ ErrorAsPrimitiveFut: futures::Future<Output = ()> + Send,
+ ErrorAsEnum: FnMut(&mut State,WithErrorSyntaxErrorAsEnumResponder) -> ErrorAsEnumFut,
+ ErrorAsEnumFut: futures::Future<Output = ()> + Send,
+> {
+ pub state: State,
+ pub on_open: OnOpen,
+ pub error_as_primitive: ErrorAsPrimitive,
+ pub error_as_enum: ErrorAsEnum,
+}
+
+// Unpin is never projected for the Impl struct
+impl<
+ State,
+OnOpen: FnMut(&mut State, WithErrorSyntaxControlHandle) -> OnOpenFut,
+OnOpenFut: futures::Future<Output = ()> + Send,
+ ErrorAsPrimitive: FnMut(&mut State,WithErrorSyntaxErrorAsPrimitiveResponder) -> ErrorAsPrimitiveFut,
+ ErrorAsPrimitiveFut: futures::Future<Output = ()> + Send,
+ ErrorAsEnum: FnMut(&mut State,WithErrorSyntaxErrorAsEnumResponder) -> ErrorAsEnumFut,
+ ErrorAsEnumFut: futures::Future<Output = ()> + Send,
+> ::std::marker::Unpin for WithErrorSyntaxImpl<State, OnOpen, OnOpenFut,
+ ErrorAsPrimitive,
+ ErrorAsPrimitiveFut,
+ ErrorAsEnum,
+ ErrorAsEnumFut,
+>
+{}
+
+impl<
+ State,
+OnOpen: FnMut(&mut State, WithErrorSyntaxControlHandle) -> OnOpenFut,
+OnOpenFut: futures::Future<Output = ()> + Send,
+ ErrorAsPrimitive: FnMut(&mut State,WithErrorSyntaxErrorAsPrimitiveResponder) -> ErrorAsPrimitiveFut,
+ ErrorAsPrimitiveFut: futures::Future<Output = ()> + Send,
+ ErrorAsEnum: FnMut(&mut State,WithErrorSyntaxErrorAsEnumResponder) -> ErrorAsEnumFut,
+ ErrorAsEnumFut: futures::Future<Output = ()> + Send,
+> WithErrorSyntax for WithErrorSyntaxImpl<State, OnOpen, OnOpenFut,
+ ErrorAsPrimitive,
+ ErrorAsPrimitiveFut,
+ ErrorAsEnum,
+ ErrorAsEnumFut,
+>
+{
+ type OnOpenFut = OnOpenFut;
+ fn on_open(&mut self, response_chan: WithErrorSyntaxControlHandle) -> Self::OnOpenFut {
+ (self.on_open)(&mut self.state, response_chan)
+ }
+ type ErrorAsPrimitiveFut = ErrorAsPrimitiveFut;
+ fn error_as_primitive (&mut self,
+ response_chan: WithErrorSyntaxErrorAsPrimitiveResponder
+ ) -> Self::ErrorAsPrimitiveFut
+ {
+ (self.error_as_primitive)(
+ &mut self.state,
+ response_chan
+ )
+ }
+
+ type ErrorAsEnumFut = ErrorAsEnumFut;
+ fn error_as_enum (&mut self,
+ response_chan: WithErrorSyntaxErrorAsEnumResponder
+ ) -> Self::ErrorAsEnumFut
+ {
+ (self.error_as_enum)(
+ &mut self.state,
+ response_chan
+ )
+ }
+
+}
+
+#[derive(Clone)]
+pub struct WithErrorSyntaxControlHandle {
+ inner: ::std::sync::Arc<fidl::ServeInner>,
+}
+
+impl ::std::ops::Deref for WithErrorSyntaxControlHandle {
+ type Target = ::std::sync::Arc<fidl::ServeInner>;
+
+ fn deref(&self) -> &Self::Target {
+ &self.inner
+ }
+}
+
+
+impl WithErrorSyntaxControlHandle {
+ pub fn shutdown(&self) {
+ self.inner.shutdown()
+ }}
+
+/* beginning of response types */
+#[must_use = "FIDL methods require a response to be sent"]
+pub struct WithErrorSyntaxErrorAsPrimitiveResponder {
+ control_handle: ::std::mem::ManuallyDrop<WithErrorSyntaxControlHandle>,
+ tx_id: u32,
+ ordinal: u32,
+}
+
+impl ::std::ops::Drop for WithErrorSyntaxErrorAsPrimitiveResponder {
+ fn drop(&mut self) {
+ // Shutdown the channel if the responder is dropped without sending a response
+ // so that the client doesn't hang. To prevent this behavior, some methods
+ // call "drop_without_shutdown"
+ self.control_handle.shutdown();
+ // Safety: drops once, never accessed again
+ unsafe { ::std::mem::ManuallyDrop::drop(&mut self.control_handle) };
+ }
+}
+
+impl WithErrorSyntaxErrorAsPrimitiveResponder {
+ pub fn control_handle(&self) -> &WithErrorSyntaxControlHandle {
+ &self.control_handle
+ }
+
+ /// Drop the Responder without setting the channel to shutdown.
+ ///
+ /// This method shouldn't normally be used-- instead, send a response
+ /// to prevent the channel from shutting down.
+ pub fn drop_without_shutdown(mut self) {
+ // Safety: drops once, never accessed again due to mem::forget
+ unsafe { ::std::mem::ManuallyDrop::drop(&mut self.control_handle) };
+ // Prevent Drop from running (which would shut down the channel)
+ ::std::mem::forget(self);
+ }
+
+ /// Sends a response to the FIDL transaction.
+ ///
+ /// Sets the channel to shutdown if an error occurs.
+ pub fn send(self,mut result: &mut WithErrorSyntaxErrorAsPrimitiveResult,) -> Result<(), fidl::Error> {
+ let r = self.send_raw(result,);
+ if r.is_err() {
+ self.control_handle.shutdown();
+ }
+ self.drop_without_shutdown();
+ r
+ }
+
+ /// Similar to "send" but does not shutdown the channel if
+ /// an error occurs.
+ pub fn send_no_shutdown_on_err(self,mut result: &mut WithErrorSyntaxErrorAsPrimitiveResult,) -> Result<(), fidl::Error> {
+ let r = self.send_raw(result,);
+ self.drop_without_shutdown();
+ r
+ }
+
+ fn send_raw(&self,mut result: &mut WithErrorSyntaxErrorAsPrimitiveResult,) -> Result<(), fidl::Error> {
+ let header = fidl::encoding::TransactionHeader {
+ tx_id: self.tx_id,
+ flags: 0,
+ ordinal: self.ordinal,
+ };
+
+ let mut response = (result);
+
+ let mut msg = fidl::encoding::TransactionMessage {
+ header,
+ body: &mut response,
+ };
+
+ ::fidl::encoding::with_tls_coding_bufs(|bytes, handles| {
+ ::fidl::encoding::Encoder::encode(bytes, handles, &mut msg)?;
+ self.control_handle.inner.channel().write(&*bytes, &mut *handles)
+ .map_err(fidl::Error::ServerResponseWrite)?;
+ Ok(())
+ })
+ }
+}
+#[must_use = "FIDL methods require a response to be sent"]
+pub struct WithErrorSyntaxErrorAsEnumResponder {
+ control_handle: ::std::mem::ManuallyDrop<WithErrorSyntaxControlHandle>,
+ tx_id: u32,
+ ordinal: u32,
+}
+
+impl ::std::ops::Drop for WithErrorSyntaxErrorAsEnumResponder {
+ fn drop(&mut self) {
+ // Shutdown the channel if the responder is dropped without sending a response
+ // so that the client doesn't hang. To prevent this behavior, some methods
+ // call "drop_without_shutdown"
+ self.control_handle.shutdown();
+ // Safety: drops once, never accessed again
+ unsafe { ::std::mem::ManuallyDrop::drop(&mut self.control_handle) };
+ }
+}
+
+impl WithErrorSyntaxErrorAsEnumResponder {
+ pub fn control_handle(&self) -> &WithErrorSyntaxControlHandle {
+ &self.control_handle
+ }
+
+ /// Drop the Responder without setting the channel to shutdown.
+ ///
+ /// This method shouldn't normally be used-- instead, send a response
+ /// to prevent the channel from shutting down.
+ pub fn drop_without_shutdown(mut self) {
+ // Safety: drops once, never accessed again due to mem::forget
+ unsafe { ::std::mem::ManuallyDrop::drop(&mut self.control_handle) };
+ // Prevent Drop from running (which would shut down the channel)
+ ::std::mem::forget(self);
+ }
+
+ /// Sends a response to the FIDL transaction.
+ ///
+ /// Sets the channel to shutdown if an error occurs.
+ pub fn send(self,mut result: &mut WithErrorSyntaxErrorAsEnumResult,) -> Result<(), fidl::Error> {
+ let r = self.send_raw(result,);
+ if r.is_err() {
+ self.control_handle.shutdown();
+ }
+ self.drop_without_shutdown();
+ r
+ }
+
+ /// Similar to "send" but does not shutdown the channel if
+ /// an error occurs.
+ pub fn send_no_shutdown_on_err(self,mut result: &mut WithErrorSyntaxErrorAsEnumResult,) -> Result<(), fidl::Error> {
+ let r = self.send_raw(result,);
+ self.drop_without_shutdown();
+ r
+ }
+
+ fn send_raw(&self,mut result: &mut WithErrorSyntaxErrorAsEnumResult,) -> Result<(), fidl::Error> {
+ let header = fidl::encoding::TransactionHeader {
+ tx_id: self.tx_id,
+ flags: 0,
+ ordinal: self.ordinal,
+ };
+
+ let mut response = (result);
+
+ let mut msg = fidl::encoding::TransactionMessage {
+ header,
+ body: &mut response,
+ };
+
+ ::fidl::encoding::with_tls_coding_bufs(|bytes, handles| {
+ ::fidl::encoding::Encoder::encode(bytes, handles, &mut msg)?;
+ self.control_handle.inner.channel().write(&*bytes, &mut *handles)
+ .map_err(fidl::Error::ServerResponseWrite)?;
+ Ok(())
+ })
+ }
+}
+
+
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct OvernetInternalProtocolMarker;
diff --git a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json_test_base.h.golden b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json_test_base.h.golden
index ecdef0664c7444d87ccd1a777b1e4f0e2c9d7dda..e85ad056fb9d71eefcd1b06166780e25ea93f0fd 100644
--- a/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json_test_base.h.golden
+++ b/garnet/go/src/fidl/compiler/backend/goldens/protocols.test.fidl.json_test_base.h.golden
@@ -82,6 +82,19 @@ class WithAndWithoutRequestResponse_TestBase : public WithAndWithoutRequestRespo
NotImplemented_("WithRequestWithResponse");
}
+};
+
+class WithErrorSyntax_TestBase : public WithErrorSyntax {
+ public:
+ virtual ~WithErrorSyntax_TestBase() { }
+ virtual void NotImplemented_(const std::string& name) = 0;
+ void ErrorAsPrimitive(ErrorAsPrimitiveCallback callback) override {
+ NotImplemented_("ErrorAsPrimitive");
+ }
+ void ErrorAsEnum(ErrorAsEnumCallback callback) override {
+ NotImplemented_("ErrorAsEnum");
+ }
+
};
} // namespace testing
} // namespace name
diff --git a/garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl b/garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl
index 9fea07204f08d8b1e91a1dda98fedf134167216b..63578a635b65d0900bc54245ff3d60fccce592d7 100644
--- a/garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl
+++ b/garnet/go/src/fidl/compiler/backend/typestest/protocols.test.fidl
@@ -11,6 +11,16 @@ protocol WithAndWithoutRequestResponse {
-> OnWithResponse(string ret);
};
+enum ErrorEnun {
+ ERR_FOO = 1;
+ ERR_BAR = 2;
+};
+
+protocol WithErrorSyntax {
+ ErrorAsPrimitive() -> () error uint32;
+ ErrorAsEnum() -> () error ErrorEnun;
+};
+
[Transport="OvernetInternal"]
protocol OvernetInternalProtocol {
MethodA(int64 a, int64 b);