EXPECT_TRUE(IsTypeLegalizedWithMlir(TypeID::get<TF::ModOp>()));
  EXPECT_FALSE(HasTf2XlaFallback(TypeID::get<TF::ModOp>()));
  EXPECT_FALSE(IsOpAllowedTf2xlaFallback(TypeID::get<TF::ModOp>()));
  EXPECT_FALSE(IsOpAllowedTf2xlaPreferred(TypeID::get<TF::ModOp>()));
}

TEST_F(LegalizationOpConfigTest, ExpectsTrueForTF2XLATypeID) {
  EXPECT_TRUE(HasTf2XlaFallback(TypeID::get<TF::AllOp>()));

bool IsDynamicPadderOp(const TypeID& type_id);

// Returns True if this op has a Tf2XLA fallback. Currently, this is not the
// inverse of the !IsOpLegalizedWithMlir, but it should be.
bool HasTf2XlaFallback(const TypeID& type_id);

// Whether this type is allowed to have a TF2XLA fallback.
bool IsOpAllowedTf2xlaFallback(const TypeID& type_id);

// Whether this type is Preferred to use a TF2XLA fallback kernel when using

          TypeID::get<mlir::TF::WhereOp>(),
          TypeID::get<mlir::TF::XlaSetDynamicDimensionSizeOp>(),
      };
  return *ops;
}

}  // namespace

bool HasTf2XlaFallback(const TypeID& type_id) {
  return IsOpTypeAllowedTf2XlaFallback(type_id) ||
         IsOpTypeAllowedTf2XlaPreferred(type_id);
}

bool IsOpLegalizedWithMlir(Operation& op) {

  if (HasStringResult(op)) return false;
  if (MatchesPattern(op, supported_ops)) return true;

  auto abstractOp = op.getRegisteredInfo();
  if (!abstractOp) return false;
  return mlir::mhlo::HasTf2XlaFallback(abstractOp->getTypeID());
}

bool IsVariant(Value value) {
  return mlir::isa<mlir::TF::VariantType>(
      getElementTypeOrSelf(value.getType()));
}

bool HasOutsideCompiledAncestor(Operation* op) {