Composite = composite.Composite


@composite.Composite(
    'TestNoOp', derived_attrs=['T: numbertype'], outputs=['o1: T'])
def _composite_no_op():
  pass


@Composite(
    'TestCompositeOp',
    inputs=['x: T', 'y: T'],
    attrs=['act: {"", "relu"}', 'trans: bool = true'],
    derived_attrs=['T: numbertype'],
    outputs=['o1: T', 'o2: T'])
def _composite_op(x, y, act, trans):
  return x + act, y + trans

flags.DEFINE_bool('gen_register_op', True,
                  'Generate register op cc file or tfr mlir file.')

flags.mark_flag_as_required('output')


@Composite('TestRandom', derived_attrs=['T: numbertype'], outputs=['o: T'])
def _composite_random_op():
  pass


def main(_):
  if FLAGS.gen_register_op:
    assert FLAGS.output.endswith('.cc')

namespace tensorflow {
namespace {

REGISTER_OP("MyAddN")
    .Input("inputs: N * T")
    .Output("sum: T")
    .Attr("N: int >= 1")
    .Attr("T: {numbertype, variant}")
    .SetIsCommutative()
    .SetIsAggregate()
    .SetShapeFn(shape_inference::UnchangedShape);

REGISTER_OP("RiscAddDummy")
    .Input("x: T")
    .Input("y: T")
    .Output("z: T")
    .Attr(

private
fun hasClassFlags(kmClassSupplier: Supplier<KmClass>, memberType: MemberType, jvmSignature: String, predicate: FlagsPredicate): Boolean {
    val kmClass = kmClassSupplier.get()
    return when (memberType) {
        MemberType.TYPE -> hasTypeFlags(kmClass, jvmSignature, predicate)
        MemberType.FIELD -> hasPropertyFlags(kmClass::properties, jvmSignature, predicate)

        }
}


internal
enum class MemberType {
    TYPE, CONSTRUCTOR, FIELD, METHOD
}


private
fun memberTypeFor(member: CtMember): MemberType =
    when (member) {
        is CtConstructor -> MemberType.CONSTRUCTOR
        is CtField -> MemberType.FIELD
        is CtMethod -> MemberType.METHOD