if (!converter.isLegal(convert_op.getOperand().getType())) {
    auto other_convert_op = dyn_cast_or_null<OtherConvertOp>(
        convert_op.getOperand().getDefiningOp());
    return other_convert_op &&
           converter.isLegal(other_convert_op.getOperand().getType());
  } else if (!converter.isLegal(convert_op.getResult().getType())) {
    if (!convert_op.getResult().hasOneUse()) {

      builder_.getUnknownLoc(), /*value=*/10, builder_.getI32Type());

  ConversionTarget target =
      GetDefaultLegalConversionTargets(context_, /*legalize_chlo=*/false);
  EXPECT_TRUE(target.isLegal(const_int));
}

TEST_F(XlaLegalizeTargetsTest, AllowsCHLODialect) {
  auto const_int = builder_.create<chlo::ConstantOp>(
      builder_.getUnknownLoc(), builder_.getI32TensorAttr({42}));

  ConversionTarget target =

    return true;
  }
  return IsStaticOperation(op);
}

bool IsDefaultConversionLegal(
    Operation* op, const ConversionTarget& default_conversion_target) {
  if (!default_conversion_target.isLegal(op)) {
    emitError(op->getLoc()) << "Could not legalize op: " << op->getName();
    return false;
  }
  return true;
}

void VerifyTFXLALegalization::runOnOperation() {

    "Counts the number of ops that has qint types" /*metric description*/,
    "op_name" /*metric label*/);

// Returns wether a type is illegal. Here we consider TF qint types illegal.
// See pass description in passes.td for more info about how illegal types are
// treated in this pass.
bool IsIllegalType(Type type) {
  return IsTFQintType(getElementTypeOrSelf(type));
}

	// it decides there are type errors.
	x :=
		len(m0)+
		len(m1)+	// ERROR "illegal|invalid|must be"
		len(m2)+	// ERROR "illegal|invalid|must be"
		len(m3)+
		len(m4)+	// ERROR "illegal|invalid|must be"

		len(s0)+
		len(s1)+	// ERROR "illegal|invalid|must be"
		len(s2)+	// ERROR "illegal|invalid|must be"
		len(s3)+
		len(s4)+	// ERROR "illegal|invalid|must be"

		len(a0)+
		len(a1)+
		len(a2)+

		cap(a0)+

	MOVM.IB	[R0-R4], (F1)      // ERROR "illegal base register"
	MOVM.DB	[R0-R4], (F1)      // ERROR "illegal base register"
	MOVW	R0<<0(F1), R1      // ERROR "illegal base register"
	MOVB	R0<<0(F1), R1      // ERROR "illegal base register"
	MOVW	R1, R0<<0(F1)      // ERROR "illegal base register"
	MOVB	R2, R0<<0(F1)      // ERROR "illegal base register"
	MOVF	0x00ffffff(F2), F1 // ERROR "illegal base register"

	LDADDALD	R5, (R6), RSP                            // ERROR "illegal combination"
	LDADDALW	R5, (R6), RSP                            // ERROR "illegal combination"
	LDADDALH	R5, (R6), RSP                            // ERROR "illegal combination"
	LDADDALB	R5, (R6), RSP                            // ERROR "illegal combination"
	LDADDD	R5, (R6), RSP                                    // ERROR "illegal combination"

// license that can be found in the LICENSE file.

package main
var v1 = ([10]int)(nil);	// ERROR "illegal|nil|invalid"
var v2 [10]int = nil;		// ERROR "illegal|nil|incompatible"
var v3 [10]int;
var v4 = nil;	// ERROR "nil"
func main() {
	v3 = nil;		// ERROR "illegal|nil|incompatible"

package main
type I int
type S struct { f map[I]int }
var v1 = S{ make(map[int]int) }		// ERROR "cannot|illegal|incompatible|wrong"
var v2 map[I]int = map[int]int{}	// ERROR "cannot|illegal|incompatible|wrong"

package main

func putint(digits *string) {
	var i byte;
	i = (*digits)[7];  // compiles
	i = digits[7];  // ERROR "illegal|is not|invalid"
	_ = i;
}

func main() {
	s := "asdfasdfasdfasdf";
	putint(&s);
}

/*
bug022.go:8: illegal types for operand
	(*<string>*STRING) INDEXPTR (<int32>INT32)
bug022.go:8: illegal types for operand
	(<uint8>UINT8) AS