*
   * <p><b>Comparison to {@code java.util.Optional}:</b> this method has no equivalent in Java 8's
   * {@code Optional} class. However, this common usage:
   *
   * <pre>{@code
   * for (Foo foo : possibleFoo.asSet()) {
   *   doSomethingWith(foo);
   * }
   * }</pre>
   *
   * ... can be replaced with:
   *
   * <pre>{@code
   * possibleFoo.ifPresent(foo -> doSomethingWith(foo));
   * }</pre>
   *

   *
   * <p><b>Comparison to {@code java.util.Optional}:</b> this method has no equivalent in Java 8's
   * {@code Optional} class. However, this common usage:
   *
   * <pre>{@code
   * for (Foo foo : possibleFoo.asSet()) {
   *   doSomethingWith(foo);
   * }
   * }</pre>
   *
   * ... can be replaced with:
   *
   * <pre>{@code
   * possibleFoo.ifPresent(foo -> doSomethingWith(foo));
   * }</pre>
   *

        dst_asset_file = file_io.join(curr_dst_dir, asset_file_name)

        file_io.copy_v2(src_asset_file, dst_asset_file)
        logging.info(
            'Copied asset file: %s -> %s', src_asset_file, dst_asset_file
        )


def _validate_representative_dataset(
    representative_dataset: rd.RepresentativeDatasetOrMapping,
    signature_keys: Collection[str],
) -> None:

    return RankedTensorType::get(
        {}, TF::ResourceType::get({type}, type.getContext()));
  }

  if (auto asset = llvm::dyn_cast<AssetOp>(op)) {
    return RankedTensorType::get({}, TF::StringType::get(asset.getContext()));
  }

  op->emitError() << "unknown symbol operation";
  return {};
}

// Check that the initializers list is empty.
// CHECK: "tf_saved_model.session_initializer"()
// CHECK-SAME: initializers = []

  "tf_saved_model.asset"() {filename = "assets/file.txt", sym_name = "__tf_saved_model_asset0_file.txt"} : () -> ()

  func.func @NoOp(%arg: tensor<!tf_type.string> {tf_saved_model.bound_input = @__tf_saved_model_asset0_file.txt})

        /*allow_mutable_tensors=*/pass_config.enable_tflite_variables));
  }

  if (!saved_model_dir.empty()) {
    // This pass 'freezes' tf saved model asset ops and inlines as string values
    // in a format of the tf constant op.
    pass_manager->addPass(
        mlir::tf_saved_model::CreateFreezeAssetsPass(saved_model_dir.str()));
  }

        if (capabilitiesRules == null) {
            return capabilities;
        }

        DefaultMutableCapabilitiesMetadata mutableCapabilities;
        if (capabilities.asSet().isEmpty()) {
            // we must add the implicit capability here because it is assumed that if there's a rule
            // "addCapability" would effectively _add_ a capability, so the implicit one must not be forgotten

        Map<String, String> targetAttributes = AttributesToMapConverter.convertToMap(targetComponentVariant.getAttributes());
        List<Capability> capabilities = targetComponentVariant.getCapabilities().asSet().stream()
            .map(TransformStepNode::convertCapability)
            .collect(Collectors.toList());

        return new DefaultPlannedTransformStepIdentity(
            consumerBuildPath,

    private static void writeCapabilities(Encoder encoder, ImmutableCapabilities capabilities) throws IOException {
        ImmutableSet<ImmutableCapability> capabilitiesSet = capabilities.asSet();
        encoder.writeSmallInt(capabilitiesSet.size());
        for (Capability capability : capabilitiesSet) {
            boolean shadowed = capability instanceof ShadowedCapability;
            if (shadowed) {

      ctx, module_op));

  FailureOr<SmallVector<AssetFileDef>> asset_file_defs =
      quant::ConvertAssetArgs(module_op);
  if (failed(asset_file_defs)) {
    return absl::InternalError("Failed to convert asset args.");
  }

  return *asset_file_defs;
}