auto deserialized = DeserializeStablehlo(context, op);
  if (!deserialized.ok()) {
    return op.emitOpError()
           << "failed to deserialize StableHLO module from XlaCallModule: "
           << deserialized.status().ToString();
  }
  OwningOpRef<ModuleOp> stablehlo_module = *std::move(deserialized);

  CopyStablehloModuleAttrs(*stablehlo_module, op);

        deserialize(serialize(action))

    private
    fun <T> serialize(action: TestableIsolatedAction<T>) =
        IsolatedActionSerializer(ownerGradle(), DefaultBeanStateWriterLookup(), isolatedActionCodecsFactory())
            .serialize(action)

    private
    fun <T> deserialize(serialized: SerializedIsolatedActionGraph<TestableIsolatedAction<T>>) =

package org.gradle.internal.serialize;

import org.gradle.internal.UncheckedException;

import javax.annotation.Nullable;

/**
 * A {@code PlaceholderException} is used when an assertion error cannot be serialized or deserialized.
 */
public class PlaceholderAssertionError extends AssertionError implements PlaceholderExceptionSupport {
    private final String exceptionClassName;
    private final Throwable getMessageException;

         * value is serialized and deserialized, so the correct class is returned. In the latter case, the result
         * is returned directly, which means it is not an instance of the expected class unless we allow that class
         * to leak through here. Should be fixed in the worker API, so that it always serializes/deserializes results.
         */

        and:
        Isolatable<?>[] newIsolatables = deserialize()

        then:
        newIsolatables[0].isolate() == properties
    }

    def "can serialize/deserialize isolated Array"() {
        String[] array = ["foo", "bar"]

        when:
        serialize(isolatableFactory.isolate(array))

        and:
        Isolatable<?>[] newIsolatables = deserialize()

        then:

import org.gradle.internal.UncheckedException;
import org.gradle.internal.scan.UsedByScanPlugin;

import javax.annotation.Nullable;

/**
 * A {@code PlaceholderException} is used when an exception cannot be serialized or deserialized.
 */
@UsedByScanPlugin
public class PlaceholderException extends RuntimeException implements PlaceholderExceptionSupport {
    private final String exceptionClassName;

import java.util.IdentityHashMap


/**
 * Serialized state of an object graph containing one or more [IsolatedAction]s.
 *
 * @param G type of the root object stored in [graph]
 */
internal
class SerializedIsolatedActionGraph<G>(
    /**
     * The serialized graph.
     */
    val graph: ByteArray,

    /**
     * External references that are not serialized directly as part of the [graph].

     */
    TreeFormatter describeContents(TreeFormatter formatter);

    /**
     * Calculates the execution time value of this file collection. The resulting value is serialized to the configuration cache
     * and deserialized at execution time, utilizing the logic encapsulated within the value.
     */
    default Optional<FileCollectionExecutionTimeValue> calculateExecutionTimeValue() {
        return Optional.empty();

            withProblem("Build file 'build.gradle': line 3: registration of listener on 'Gradle.addListener' is unsupported")
            withProblem("Task `:broken` of type `org.gradle.api.DefaultTask`: cannot deserialize object of type 'org.gradle.api.Project' as these are not supported with the configuration cache.")

    private
    val pluginsSchema: AnalysisSchema = schema

    @Test
    fun `schema is serializable`() {
        val serialized = SchemaSerialization.schemaToJsonString(pluginsSchema)
        val deserialized = SchemaSerialization.schemaFromJsonString(serialized)

        val result = deserialized.resolve(
            """
            plugins {
                id("test")
            }
            """.trimIndent()
        )