tools/fidl/fidlgen_dart/goldens/anonymous_async.dart.golden

// WARNING: This file is machine generated by fidlgen.
// @dart = 2.12

// fidl_experiment = no_optional_structs
// fidl_experiment = output_index_json
// fidl_experiment = simple_empty_response_syntax
// fidl_experiment = unknown_interactions
// fidl_experiment = unknown_interactions_mandate

library fidl_test_anonymous_async;

import 'dart:async' as $async;
import 'dart:core' hide Set;
import 'dart:developer';
import 'dart:typed_data';

import 'package:fidl/fidl.dart' as $fidl;
import 'package:meta/meta.dart';
import 'package:zircon/zircon.dart' as $zircon;

// ignore_for_file: always_specify_types
// ignore_for_file: avoid_positional_boolean_parameters
// ignore_for_file: avoid_returning_null
// ignore_for_file: cascade_invocations
// ignore_for_file: constant_identifier_names
// ignore_for_file: directives_ordering
// ignore_for_file: one_member_abstracts
// ignore_for_file: prefer_constructors_over_static_methods
// ignore_for_file: prefer_single_quotes
// ignore_for_file: public_member_api_docs
// ignore_for_file: unused_import
// ignore_for_file: unused_local_variable
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: library_prefixes
// ignore_for_file: prefer_typing_uninitialized_variables
// ignore_for_file: avoid_js_rounded_ints
// ignore_for_file: unnecessary_parenthesis
// ignore_for_file: always_put_required_named_parameters_first
// ignore_for_file: prefer_generic_function_type_aliases
// ignore_for_file: prefer_equal_for_default_values
// ignore_for_file: avoid_catches_without_on_clauses
// ignore_for_file: unused_shown_name
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: comment_references
// ignore_for_file: avoid_unused_constructor_parameters
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: override_on_non_overriding_member

class Op extends $fidl.Enum {
  static final Map<int, Op> _values = {
    0x1: add,
    0x2: mul,
    0x3: div,
  };
  factory Op(int _v) {
    if (!_values.containsKey(_v)) {
      _values[_v] = Op._(_v, true);
    }
    return _values[_v]!;
  }
  static const Op add = Op._(0x1, false);
  static const Op mul = Op._(0x2, false);
  static const Op div = Op._(0x3, false);

  /// Default unknown placeholder.
  static const Op $unknown = Op._(0xffffffff, true);

  const Op._(this.$value, this._isUnknown);

  @override
  final int $value;

  final bool _isUnknown;

  static const Map<String, Op> $valuesMap = {
    r'add': add,
    r'mul': mul,
    r'div': div,
  };

  static const List<Op> $values = [
    add,
    mul,
    div,
  ];

  static Op? $valueOf(String name) => $valuesMap[name];

  @override
  bool isUnknown() {
    return _isUnknown;
  }

  static Op _ctor(int v) => Op(v);
}

const $fidl.EnumType<Op> kOp_Type = $fidl.EnumType<Op>(
    type: $fidl.Uint32Type(),
    values: {0x1: null, 0x2: null, 0x3: null},
    ctor: Op._ctor);

class SomeProtocolSomeMethodError extends $fidl.Enum {
  static final Map<int, SomeProtocolSomeMethodError> _values = {
    0x1: errorOne,
    0x2: errorTwo,
  };
  factory SomeProtocolSomeMethodError(int _v) {
    if (!_values.containsKey(_v)) {
      _values[_v] = SomeProtocolSomeMethodError._(_v, true);
    }
    return _values[_v]!;
  }
  static const SomeProtocolSomeMethodError errorOne =
      SomeProtocolSomeMethodError._(0x1, false);
  static const SomeProtocolSomeMethodError errorTwo =
      SomeProtocolSomeMethodError._(0x2, false);

  /// Default unknown placeholder.
  static const SomeProtocolSomeMethodError $unknown =
      SomeProtocolSomeMethodError._(0xffffffff, true);

  const SomeProtocolSomeMethodError._(this.$value, this._isUnknown);

  @override
  final int $value;

  final bool _isUnknown;

  static const Map<String, SomeProtocolSomeMethodError> $valuesMap = {
    r'errorOne': errorOne,
    r'errorTwo': errorTwo,
  };

  static const List<SomeProtocolSomeMethodError> $values = [
    errorOne,
    errorTwo,
  ];

  static SomeProtocolSomeMethodError? $valueOf(String name) => $valuesMap[name];

  @override
  bool isUnknown() {
    return _isUnknown;
  }

  static SomeProtocolSomeMethodError _ctor(int v) =>
      SomeProtocolSomeMethodError(v);
}

const $fidl.EnumType<SomeProtocolSomeMethodError>
    kSomeProtocol_SomeMethod_Error_Type =
    $fidl.EnumType<SomeProtocolSomeMethodError>(
        type: $fidl.Uint32Type(),
        values: {0x1: null, 0x2: null},
        ctor: SomeProtocolSomeMethodError._ctor);

class BitsMember extends $fidl.Bits {
  factory BitsMember(int _v) {
    return BitsMember._(_v);
  }
  static const BitsMember bitOne = BitsMember._(0x1);
  static const BitsMember bitTwo = BitsMember._(0x2);
  static const BitsMember $none = BitsMember._(0);
  static const BitsMember $mask = BitsMember._(0x3);

  const BitsMember._(this.$value);

  BitsMember operator |(BitsMember other) {
    return BitsMember._($value | other.$value);
  }

  BitsMember operator &(BitsMember other) {
    return BitsMember._($value & other.$value);
  }

  BitsMember operator ~() {
    return BitsMember._(~$value & $mask.$value);
  }

  @override
  final int $value;

  @override
  bool hasUnknownBits() {
    return getUnknownBits() != 0;
  }

  @override
  int getUnknownBits() {
    return $value & ~$mask.$value;
  }

  static BitsMember _ctor(int v) => BitsMember(v);
}

const $fidl.BitsType<BitsMember> kBitsMember_Type = $fidl.BitsType<BitsMember>(
    type: $fidl.Uint32Type(), ctor: BitsMember._ctor);

class Flags extends $fidl.Bits {
  factory Flags(int _v) {
    return Flags._(_v);
  }
  static const Flags inline = Flags._(0x1);
  static const Flags $none = Flags._(0);
  static const Flags $mask = Flags._(0x1);

  const Flags._(this.$value);

  Flags operator |(Flags other) {
    return Flags._($value | other.$value);
  }

  Flags operator &(Flags other) {
    return Flags._($value & other.$value);
  }

  Flags operator ~() {
    return Flags._(~$value & $mask.$value);
  }

  @override
  final int $value;

  @override
  bool hasUnknownBits() {
    return getUnknownBits() != 0;
  }

  @override
  int getUnknownBits() {
    return $value & ~$mask.$value;
  }

  static Flags _ctor(int v) => Flags(v);
}

const $fidl.BitsType<Flags> kFlags_Type =
    $fidl.BitsType<Flags>(type: $fidl.Uint16Type(), ctor: Flags._ctor);

enum ExpressionTag {
  $unknown,
  value, // 0x1
  binOp, // 0x2
  functionApplication, // 0x3
}

const Map<int, ExpressionTag> _ExpressionTag_map = {
  1: ExpressionTag.value,
  2: ExpressionTag.binOp,
  3: ExpressionTag.functionApplication,
};

class Expression extends $fidl.Union {
  const Expression.withValue(int value)
      : _ordinal = 1,
        _data = value;

  const Expression.withBinOp(OverrideTest value)
      : _ordinal = 2,
        _data = value;

  const Expression.withFunctionApplication(FunctionApplication value)
      : _ordinal = 3,
        _data = value;
  const Expression.with$UnknownData(this._ordinal, $fidl.UnknownRawData data)
      : _data = data;

  Expression._(int ordinal, Object data)
      : _ordinal = ordinal,
        _data = data;

  final int _ordinal;
  final _data;

  ExpressionTag get $tag =>
      _ExpressionTag_map[_ordinal] ?? ExpressionTag.$unknown;

  int? get value {
    if (_ordinal != 1) {
      return null;
    }
    return _data;
  }

  OverrideTest? get binOp {
    if (_ordinal != 2) {
      return null;
    }
    return _data;
  }

  FunctionApplication? get functionApplication {
    if (_ordinal != 3) {
      return null;
    }
    return _data;
  }

  $fidl.UnknownRawData? get $unknownData {
    switch (_ordinal) {
      case 1:
      case 2:
      case 3:
        return null;
      default:
        return _data;
    }
  }

  @override
  int get $ordinal => _ordinal;

  @override
  Object get $data => _data;

  static Expression _ctor(int ordinal, Object data) {
    return Expression._(ordinal, data);
  }
}

// See fxbug.dev/7644:
// ignore: recursive_compile_time_constant
const $fidl.UnionType<Expression> kExpression_Type =
    $fidl.UnionType<Expression>(
  members: <int, $fidl.FidlType>{
    1: $fidl.Uint64Type(),
    2: kOverrideTest_Type,
    3: kFunctionApplication_Type,
  },
  ctor: Expression._ctor,
  flexible: true,
  resource: false,
);
// See fxbug.dev/7644:
// ignore: recursive_compile_time_constant
const $fidl.NullableUnionType<Expression> kExpression_OptType =
    $fidl.NullableUnionType<Expression>(
  members: <int, $fidl.FidlType>{
    1: $fidl.Uint64Type(),
    2: kOverrideTest_Type,
    3: kFunctionApplication_Type,
  },
  ctor: Expression._ctor,
  flexible: true,
  resource: false,
);

enum SomeProtocolSomeMethodResultTag {
  response, // 0x1
  err, // 0x2
}

const Map<int, SomeProtocolSomeMethodResultTag>
    _SomeProtocolSomeMethodResultTag_map = {
  1: SomeProtocolSomeMethodResultTag.response,
  2: SomeProtocolSomeMethodResultTag.err,
};

class SomeProtocolSomeMethodResult extends $fidl.Union {
  const SomeProtocolSomeMethodResult.withResponse(
      SomeProtocolSomeMethodResponse value)
      : _ordinal = 1,
        _data = value;

  const SomeProtocolSomeMethodResult.withErr(SomeProtocolSomeMethodError value)
      : _ordinal = 2,
        _data = value;

  SomeProtocolSomeMethodResult._(int ordinal, Object data)
      : _ordinal = ordinal,
        _data = data;

  final int _ordinal;
  final _data;

  SomeProtocolSomeMethodResultTag get $tag =>
      _SomeProtocolSomeMethodResultTag_map[_ordinal]!;

  SomeProtocolSomeMethodResponse? get response {
    if (_ordinal != 1) {
      return null;
    }
    return _data;
  }

  SomeProtocolSomeMethodError? get err {
    if (_ordinal != 2) {
      return null;
    }
    return _data;
  }

  $fidl.UnknownRawData? get $unknownData {
    switch (_ordinal) {
      case 1:
      case 2:
        return null;
      default:
        return _data;
    }
  }

  @override
  int get $ordinal => _ordinal;

  @override
  Object get $data => _data;

  static SomeProtocolSomeMethodResult _ctor(int ordinal, Object data) {
    return SomeProtocolSomeMethodResult._(ordinal, data);
  }
}

// See fxbug.dev/7644:
// ignore: recursive_compile_time_constant
const $fidl.UnionType<SomeProtocolSomeMethodResult>
    kSomeProtocol_SomeMethod_Result_Type =
    $fidl.UnionType<SomeProtocolSomeMethodResult>(
  members: <int, $fidl.FidlType>{
    1: kSomeProtocol_SomeMethod_Response_Type,
    2: kSomeProtocol_SomeMethod_Error_Type,
  },
  ctor: SomeProtocolSomeMethodResult._ctor,
  flexible: false,
  resource: false,
);
// See fxbug.dev/7644:
// ignore: recursive_compile_time_constant
const $fidl.NullableUnionType<SomeProtocolSomeMethodResult>
    kSomeProtocol_SomeMethod_Result_OptType =
    $fidl.NullableUnionType<SomeProtocolSomeMethodResult>(
  members: <int, $fidl.FidlType>{
    1: kSomeProtocol_SomeMethod_Response_Type,
    2: kSomeProtocol_SomeMethod_Error_Type,
  },
  ctor: SomeProtocolSomeMethodResult._ctor,
  flexible: false,
  resource: false,
);

enum UnionMemberTag {
  $unknown,
  unionData, // 0x2
}

const Map<int, UnionMemberTag> _UnionMemberTag_map = {
  2: UnionMemberTag.unionData,
};

class UnionMember extends $fidl.Union {
  const UnionMember.withUnionData(int value)
      : _ordinal = 2,
        _data = value;
  const UnionMember.with$UnknownData(this._ordinal, $fidl.UnknownRawData data)
      : _data = data;

  UnionMember._(int ordinal, Object data)
      : _ordinal = ordinal,
        _data = data;

  final int _ordinal;
  final _data;

  UnionMemberTag get $tag =>
      _UnionMemberTag_map[_ordinal] ?? UnionMemberTag.$unknown;

  int? get unionData {
    if (_ordinal != 2) {
      return null;
    }
    return _data;
  }

  $fidl.UnknownRawData? get $unknownData {
    switch (_ordinal) {
      case 2:
        return null;
      default:
        return _data;
    }
  }

  @override
  int get $ordinal => _ordinal;

  @override
  Object get $data => _data;

  static UnionMember _ctor(int ordinal, Object data) {
    return UnionMember._(ordinal, data);
  }
}

// See fxbug.dev/7644:
// ignore: recursive_compile_time_constant
const $fidl.UnionType<UnionMember> kUnionMember_Type =
    $fidl.UnionType<UnionMember>(
  members: <int, $fidl.FidlType>{
    2: $fidl.Uint8Type(),
  },
  ctor: UnionMember._ctor,
  flexible: true,
  resource: false,
);
// See fxbug.dev/7644:
// ignore: recursive_compile_time_constant
const $fidl.NullableUnionType<UnionMember> kUnionMember_OptType =
    $fidl.NullableUnionType<UnionMember>(
  members: <int, $fidl.FidlType>{
    2: $fidl.Uint8Type(),
  },
  ctor: UnionMember._ctor,
  flexible: true,
  resource: false,
);

class OverrideTest extends $fidl.Struct {
  const OverrideTest({
    required this.op,
    this.left,
    this.right,
  });
  OverrideTest.clone(
    OverrideTest $orig, {
    Op? op,
    Expression? left,
    Expression? right,
  }) : this(
          op: op ?? $orig.op,
          left: left ?? $orig.left,
          right: right ?? $orig.right,
        );

  OverrideTest.cloneWithout(
    OverrideTest $orig, {
    bool left = false,
    bool right = false,
  }) : this(
          op: $orig.op,
          left: left ? null : $orig.left,
          right: right ? null : $orig.right,
        );

  OverrideTest $cloneWith({
    Op? op,
    $fidl.OptionalNullable<Expression?> left =
        const $fidl.OptionalNullable.undefined(),
    $fidl.OptionalNullable<Expression?> right =
        const $fidl.OptionalNullable.undefined(),
  }) {
    return OverrideTest(
      op: op ?? this.op,
      left: left.or(this.left),
      right: right.or(this.right),
    );
  }

  final Op op;
  final Expression? left;
  final Expression? right;

  @override
  List<Object?> get $fields {
    return <Object?>[
      op,
      left,
      right,
    ];
  }

  static const $fieldType0 = kOp_Type;
  static const $fieldType1 = kExpression_OptType;
  static const $fieldType2 = kExpression_OptType;

  @override
  void $encode($fidl.Encoder $encoder, int $offset, int $depth) {
    $fieldType0.encode($encoder, op, $offset + 0, $depth);
    $fieldType1.encode($encoder, left, $offset + 8, $depth);
    $fieldType2.encode($encoder, right, $offset + 24, $depth);
  }

  static OverrideTest _structDecode(
      $fidl.Decoder $decoder, int $offset, int $depth) {
    switch ($decoder.wireFormat) {
      case $fidl.WireFormat.v2:
        $decoder.checkPadding($offset + 4, 4);
        return OverrideTest(
            op: $fieldType0.decode($decoder, $offset + 0, $depth),
            left: $fieldType1.decode($decoder, $offset + 8, $depth),
            right: $fieldType2.decode($decoder, $offset + 24, $depth));
    }
  }
}

// See fxbug.dev/7644:
// ignore: recursive_compile_time_constant
const $fidl.StructType<OverrideTest> kOverrideTest_Type =
    $fidl.StructType<OverrideTest>(
        inlineSize: 40, structDecode: OverrideTest._structDecode);

class SomeProtocolSomeMethodResponse extends $fidl.Struct {
  const SomeProtocolSomeMethodResponse({
    required this.bitsMember,
  });
  SomeProtocolSomeMethodResponse.clone(
    SomeProtocolSomeMethodResponse $orig, {
    BitsMember? bitsMember,
  }) : this(
          bitsMember: bitsMember ?? $orig.bitsMember,
        );

  SomeProtocolSomeMethodResponse $cloneWith({
    BitsMember? bitsMember,
  }) {
    return SomeProtocolSomeMethodResponse(
      bitsMember: bitsMember ?? this.bitsMember,
    );
  }

  final BitsMember bitsMember;

  @override
  List<Object?> get $fields {
    return <Object?>[
      bitsMember,
    ];
  }

  static const $fieldType0 = kBitsMember_Type;

  @override
  void $encode($fidl.Encoder $encoder, int $offset, int $depth) {
    $fieldType0.encode($encoder, bitsMember, $offset + 0, $depth);
  }

  static SomeProtocolSomeMethodResponse _structDecode(
      $fidl.Decoder $decoder, int $offset, int $depth) {
    switch ($decoder.wireFormat) {
      case $fidl.WireFormat.v2:
        return SomeProtocolSomeMethodResponse(
            bitsMember: $fieldType0.decode($decoder, $offset + 0, $depth));
    }
  }
}

// See fxbug.dev/7644:
// ignore: recursive_compile_time_constant
const $fidl.StructType<SomeProtocolSomeMethodResponse>
    kSomeProtocol_SomeMethod_Response_Type =
    $fidl.StructType<SomeProtocolSomeMethodResponse>(
        inlineSize: 4,
        structDecode: SomeProtocolSomeMethodResponse._structDecode);

class TableData extends $fidl.Struct {
  const TableData({
    required this.data,
  });
  TableData.clone(
    TableData $orig, {
    int? data,
  }) : this(
          data: data ?? $orig.data,
        );

  TableData $cloneWith({
    int? data,
  }) {
    return TableData(
      data: data ?? this.data,
    );
  }

  final int data;

  @override
  List<Object?> get $fields {
    return <Object?>[
      data,
    ];
  }

  static const $fieldType0 = $fidl.Uint8Type();

  @override
  void $encode($fidl.Encoder $encoder, int $offset, int $depth) {
    $fieldType0.encode($encoder, data, $offset + 0, $depth);
  }

  static TableData _structDecode(
      $fidl.Decoder $decoder, int $offset, int $depth) {
    switch ($decoder.wireFormat) {
      case $fidl.WireFormat.v2:
        return TableData(
            data: $fieldType0.decode($decoder, $offset + 0, $depth));
    }
  }
}

// See fxbug.dev/7644:
// ignore: recursive_compile_time_constant
const $fidl.StructType<TableData> kTableData_Type = $fidl.StructType<TableData>(
    inlineSize: 1, structDecode: TableData._structDecode);

class FunctionApplication extends $fidl.Table {
  const FunctionApplication({
    this.$unknownData,
    this.func,
    this.args,
    this.flags,
  });

  FunctionApplication._(Map<int, dynamic> argv, this.$unknownData)
      : func = argv[1],
        args = argv[3],
        flags = argv[4];

  FunctionApplication $cloneWith({
    $fidl.OptionalNullable<Map<int, $fidl.UnknownRawData>> $unknownData =
        const $fidl.OptionalNullable.undefined(),
    $fidl.OptionalNullable<String> func =
        const $fidl.OptionalNullable.undefined(),
    $fidl.OptionalNullable<List<Expression?>> args =
        const $fidl.OptionalNullable.undefined(),
    $fidl.OptionalNullable<Flags> flags =
        const $fidl.OptionalNullable.undefined(),
  }) {
    return FunctionApplication(
      func: func.or(this.func),
      args: args.or(this.args),
      flags: flags.or(this.flags),
    );
  }

  @override
  final Map<int, $fidl.UnknownRawData>? $unknownData;
  final String? func;
  final List<Expression?>? args;
  final Flags? flags;

  @override
  dynamic $field(int index) {
    switch (index) {
      case 0:
        return func;
      case 2:
        return args;
      case 3:
        return flags;
    }
    return null;
  }

  @override
  Map<int, dynamic> get $fields {
    return {
      1: func,
      3: args,
      4: flags,
    };
  }

  static FunctionApplication _ctor(Map<int, dynamic> argv,
          [Map<int, $fidl.UnknownRawData>? unknownData]) =>
      FunctionApplication._(argv, unknownData);
}

// See fxbug.dev/7644:
// ignore: recursive_compile_time_constant
const $fidl.TableType<FunctionApplication> kFunctionApplication_Type =
    $fidl.TableType<FunctionApplication>(
  inlineSize: 16,
  members: [
    $fidl.StringType(maybeElementCount: 100),
    null,
    $fidl.VectorType<Expression?, List<Expression?>>(
        element: kExpression_OptType, maybeElementCount: 5),
    kFlags_Type,
  ],
  ctor: FunctionApplication._ctor,
  resource: false,
);

class TableMember extends $fidl.Table {
  const TableMember({
    this.$unknownData,
    this.tableData,
  });

  TableMember._(Map<int, dynamic> argv, this.$unknownData)
      : tableData = argv[2];

  TableMember $cloneWith({
    $fidl.OptionalNullable<Map<int, $fidl.UnknownRawData>> $unknownData =
        const $fidl.OptionalNullable.undefined(),
    $fidl.OptionalNullable<List<TableData>> tableData =
        const $fidl.OptionalNullable.undefined(),
  }) {
    return TableMember(
      tableData: tableData.or(this.tableData),
    );
  }

  @override
  final Map<int, $fidl.UnknownRawData>? $unknownData;
  final List<TableData>? tableData;

  @override
  dynamic $field(int index) {
    switch (index) {
      case 1:
        return tableData;
    }
    return null;
  }

  @override
  Map<int, dynamic> get $fields {
    return {
      2: tableData,
    };
  }

  static TableMember _ctor(Map<int, dynamic> argv,
          [Map<int, $fidl.UnknownRawData>? unknownData]) =>
      TableMember._(argv, unknownData);
}

// See fxbug.dev/7644:
// ignore: recursive_compile_time_constant
const $fidl.TableType<TableMember> kTableMember_Type =
    $fidl.TableType<TableMember>(
  inlineSize: 16,
  members: [
    null,
    $fidl.VectorType<TableData, List<TableData>>(
        element: kTableData_Type, maybeElementCount: 10),
  ],
  ctor: TableMember._ctor,
  resource: false,
);

// someMethod: (UnionMember unionMember, TableMember tableMember) -> (BitsMember bitsMember)
const int _kSomeProtocol_SomeMethod_Ordinal = 0x22ea52ec7a5146d8;
const $fidl.MethodType _kSomeProtocol_SomeMethod_Type = $fidl.MethodType(
  request: <$fidl.MemberType>[
    $fidl.MemberType<UnionMember>(type: kUnionMember_Type, offset: 0),
    $fidl.MemberType<TableMember>(type: kTableMember_Type, offset: 16),
  ],
  response: <$fidl.MemberType>[
    $fidl.MemberType<SomeProtocolSomeMethodResult>(
        type: kSomeProtocol_SomeMethod_Result_Type, offset: 0),
  ],
  name: r"SomeProtocol.SomeMethod",
  requestInlineSizeV2: 32,
  responseInlineSizeV2: 16,
);

abstract class SomeProtocol {
  $fidl.ServiceData? get $serviceData => SomeProtocolData();
  $async.Future<BitsMember> someMethod(
      UnionMember unionMember, TableMember tableMember);
} // TODO: Remove ServiceData for non-service

class SomeProtocolData implements $fidl.ServiceData<SomeProtocol> {
  const SomeProtocolData();

  @override
  String getName() {
    return "";
  }

  @override
  $fidl.AsyncBinding getBinding() {
    return SomeProtocolBinding();
  }
}

class SomeProtocolProxy extends $fidl.AsyncProxy<SomeProtocol>
    implements SomeProtocol {
  SomeProtocolProxy()
      : super($fidl.AsyncProxyController<SomeProtocol>(
            $interfaceName: r'SomeProtocol')) {
    ctrl.onResponse = _handleResponse;
  }
  @override
  Null get $serviceData => null;

  void _handleEvent($fidl.IncomingMessage $message) {
    switch ($message.ordinal) {
      default:
        $message.closeHandles();
        ctrl.proxyError(
            $fidl.FidlError('Unexpected message ordinal: ${$message.ordinal}'));
        break;
    }
  }

  void _handleResponse($fidl.IncomingMessage $message) {
    final int $txid = $message.txid;
    if ($txid == 0) {
      _handleEvent($message);
      return;
    }
    final $async.Completer? $completer = ctrl.getCompleter($txid);
    if ($completer == null) {
      $message.closeHandles();
      return;
    }
    switch ($message.ordinal) {
      case _kSomeProtocol_SomeMethod_Ordinal:
        final String _name = _kSomeProtocol_SomeMethod_Type.name;
        $fidl.performCtrlWithExceptionHandling(
            _name, ctrl, 'method response', $completer.completeError, () {
          final List<$fidl.MemberType> $types =
              _kSomeProtocol_SomeMethod_Type.response!;
          final $wireFormat = $message.parseWireFormat();
          // ignore: prefer_const_declarations

          final SomeProtocolSomeMethodResult $response = $fidl.decodeMessage(
              $message,
              _kSomeProtocol_SomeMethod_Type.responseInlineSize($wireFormat),
              $types[0]);
          if ($response.$tag == SomeProtocolSomeMethodResultTag.response) {
            $completer.complete($response.response!.bitsMember);
          } else {
            $completer.completeError($fidl.MethodException($response.err));
          }
        });
        break;
      default:
        ctrl.proxyError(
            $fidl.FidlError('Unexpected message ordinal: ${$message.ordinal}'));
        break;
    }
  }

  @override
  $async.Future<BitsMember> someMethod(
      UnionMember unionMember, TableMember tableMember) {
    if (!ctrl.isBound) {
      return $async.Future.error(
          $fidl.FidlStateException('Proxy<${ctrl.$interfaceName}> is closed.'),
          StackTrace.current);
    }

    final $fidl.Encoder $encoder = $fidl.Encoder($fidl.kWireFormatDefault);
    $encoder.encodeMessageHeader(
        _kSomeProtocol_SomeMethod_Ordinal, 0, $fidl.CallStrictness.strict);
    final List<$fidl.MemberType> $types =
        _kSomeProtocol_SomeMethod_Type.request!;
    $fidl.encodeMessageWithCallback($encoder,
        _kSomeProtocol_SomeMethod_Type.requestInlineSize($encoder.wireFormat),
        () {
      $types[0].encode($encoder, unionMember, $fidl.kMessageHeaderSize, 1);
      $types[1].encode($encoder, tableMember, $fidl.kMessageHeaderSize, 1);
    });
    final $completer = $async.Completer<BitsMember>();
    ctrl.sendMessageWithResponse($encoder.message, $completer);
    return $completer.future;
  }
}

class SomeProtocolBinding extends $fidl.AsyncBinding<SomeProtocol> {
  SomeProtocolBinding() : super(r"SomeProtocol");

  @override
  void handleMessage(
      $fidl.IncomingMessage $message, $fidl.OutgoingMessageSink $respond) {
    final $wireFormat = $message.parseWireFormat();
    switch ($message.ordinal) {
      case _kSomeProtocol_SomeMethod_Ordinal:
        final String _name = _kSomeProtocol_SomeMethod_Type.name;
        $fidl.performWithExceptionHandling(_name, () {
          final List<$fidl.MemberType> $types =
              _kSomeProtocol_SomeMethod_Type.request!;
          // ignore: prefer_const_declarations
          final _impl = impl!;
          final $async.Future<BitsMember> $future = $fidl
              .decodeMessageWithCallback<$async.Future<BitsMember>>($message,
                  _kSomeProtocol_SomeMethod_Type.requestInlineSize($wireFormat),
                  ($fidl.Decoder $decoder, int $offset) {
            return _impl.someMethod(
              $types[0].decode($decoder, $offset, 1),
              $types[1].decode($decoder, $offset, 1),
            );
          });
          $future.then(($responseValue) {
            return SomeProtocolSomeMethodResult.withResponse(
                SomeProtocolSomeMethodResponse(bitsMember: $responseValue));
          }, onError: ($error) {
            if ($error is $fidl.MethodException) {
              return SomeProtocolSomeMethodResult.withErr($error.value);
            } else {
              return Future.error($error, StackTrace.current);
            }
          }).then(($response) {
            final $fidl.Encoder $encoder =
                $fidl.Encoder($fidl.kWireFormatDefault);
            $encoder.encodeMessageHeader(_kSomeProtocol_SomeMethod_Ordinal,
                $message.txid, $fidl.CallStrictness.strict);
            final List<$fidl.MemberType> $types =
                _kSomeProtocol_SomeMethod_Type.response!;
            $fidl.encodeMessage(
                $encoder,
                _kSomeProtocol_SomeMethod_Type
                    .responseInlineSize($encoder.wireFormat),
                $types[0],
                $response);
            $respond($encoder.message);
          }, onError: (_e) {
            $fidl.handleException(_name, _e, close);
          });
        }, close);
        break;
      default:
        $message.closeHandles();
        throw $fidl.FidlError(
            r'Unexpected message name for SomeProtocolBinding');
    }
  }
}