NativeCodeCall<"GetF32Scalar(&$_builder, " # value # ")">;

def TrueBoolAttr : AttrConstraint<CPred<"$_self.cast<::mlir::BoolAttr>().getValue()">>;

def CreateTFShapeOp : NativeCodeCall<
    "$_builder.create<TF::ShapeOp>($0.getLoc(), $1, $2)">;

def IsI32 : NativeCodeCall<
    "$_builder.getBoolAttr(getElementTypeOrSelf($0.getType()).isInteger(32))">;

def CreateTFCastOpF32 : NativeCodeCall<

    return rewriter.create<TF::ConstOp>(loc, static_shape_attr).getOutput();
  }

  // If the shape is not static, create a new ShapeOp.
  BoolAttr false_attr = rewriter.getBoolAttr(false);
  return rewriter
      .create<TF::ShapeOp>(loc, input,
                           /*use_32bit=*/false_attr)
      .getOutput();
}

mlir::TFL::MirrorPaddingType GetTFLMirrorPaddingFromString(

    TypeID::get<TF::ReshapeOp>(),
    TypeID::get<TF::ReverseV2Op>(),
    TypeID::get<TF::RFFTOp>(),
    TypeID::get<TF::RsqrtGradOp>(),
    TypeID::get<TF::ScatterNdOp>(),
    TypeID::get<TF::ShapeOp>(),
    TypeID::get<TF::SinhOp>(),
    TypeID::get<TF::SizeOp>(),
    TypeID::get<TF::SliceOp>(),
    TypeID::get<TF::SoftmaxCrossEntropyWithLogitsOp>(),
    TypeID::get<TF::SoftplusOp>(),

          loc, GetScalarOfType(
                   builder->getIntegerType(use_32bit.getValue() ? 32 : 64),
                   ranked_ty.getDimSize(idx)));
    }
  }

  auto shape = builder->create<TF::ShapeOp>(loc, input, use_32bit);
  return builder->create<TF::StridedSliceOp>(
      loc, mlir::RankedTensorType::get({}, getElementTypeOrSelf(shape)), shape,
      /*begin=*/

  std::string serialized_func_module;
  if (HasDynamicOutputs(external_outputs)) {
    FuncOp shape_op = BuildFunction(clustered_ops, external_operands,
                                    external_outputs, &builder);
    EncapsulateFuncAndSerialize(shape_op, &serialized_func_module);
  }

  builder.setInsertionPoint(&op);
  SmallVector<Value, 4> host_compute_outputs;

      return ComputeOutputComponent(ValuePort(id.getInput()), values);
    return nullptr;
  }

  if (auto shape_op = dyn_cast<TF::ShapeOp>(op)) {
    // No shape available in an unranked tensor type.
    auto operand_ty =
        mlir::dyn_cast<RankedTensorType>(shape_op.getOperand().getType());
    if (!operand_ty) return nullptr;

    // Shape op has a single output so the first element should always be zero

      shape.push_back(dim.getSExtValue());
    }
    return tensorflow::GetTypeFromTFTensorShape(shape, etype);
  }

  if (auto shape_op = dims.getDefiningOp<ShapeOp>()) {
    if (auto t = mlir::dyn_cast<ShapedType>(shape_op.getInput().getType())) {
      return t;
    }
  }

  return UnrankedTensorType::get(etype);
}

absl::StatusOr<mlir::Type> ImporterBase::InferOutputType(
    const Node& node, int idx, mlir::Builder builder) {
  DataType dtype = node.properties()->output_types[idx];

  // Returns output type given inference context.
  auto shape_ic =
      [&](shape_inference::InferenceContext* c) -> absl::StatusOr<mlir::Type> {
    // TODO(b/200093974): Post triage, consider following
    // GraphConstructor::ValidateShape in checking _output_shapes always.

    const std::vector<int32_t> *shape = nullptr,
    tflite::TensorType type = tflite::TensorType_FLOAT32,
    bool has_rank = false) {
  auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
  return tflite::CreateVariantSubType(
      _fbb,
      shape__,
      type,
      has_rank);
}