// 2. Delete the object from storage.
		// If the update succeeds, but the delete fails (network error, internal storage error, etc.),
		// a resource was previously left in a state that was non-recoverable.  We
		// check if the existing stored resource has a grace period as 0 and if so
		// attempt to delete immediately in order to recover from this scenario.

//
// Before Go 1.23, the garbage collector did not recover
// timers that had not yet expired or been stopped, so code often
// immediately deferred t.Stop after calling NewTimer, to make
// the timer recoverable when it was no longer needed.
// As of Go 1.23, the garbage collector can recover unreferenced
// timers, even if they haven't expired or been stopped.
// The Stop method is no longer necessary to help the garbage collector.

        1 * workerProcess.stopNow()
        _ * workerProcess.waitForStop() >> { throw new ExecException("waitForStop can throw") }
        notThrown(ExecException)
    }

    def "captures and rethrows unrecoverable exceptions thrown by the connection"() {
        def handler
        def processor = newProcessor()

        when:
        processor.processTestClass(Mock(TestClassRunInfo))

        then:

 */
public class CompilationFatalException extends RuntimeException implements CompilationFailedIndicator {

    public CompilationFatalException(Throwable cause) {
        super("Unrecoverable compilation error: " + cause.getMessage(), cause);
    }

// - a table storing execution count for the coverable units in each func
type pstate struct {
	// slice of unique functions
	funcs []fnfile
	// maps function to index in slice above (index acts as function ID)
	funcTable map[fnfile]uint32

	// A table storing coverage counts for each coverable unit.
	unitTable map[extcu]uint32
}

// extcu encapsulates a coverable unit within some function.
type extcu struct {

    void stop();

    /**
     * Indicate that the execution containing this {@code ObjectConnection} has been prematurely stopped.
     */
    void abort();

    /**
     * Add a callback upon unrecoverable errors, e.g. broken connection. Should not throw any exceptions because
     * this is the last line of defense.
     * @param handler the callback
     */
    void addUnrecoverableErrorHandler(Action<Throwable> handler);

type lazyObject struct {
	loader func() (RESTMapper, error)

	lock   sync.Mutex
	loaded bool
	err    error
	mapper RESTMapper
}

// NewLazyRESTMapperLoader handles unrecoverable errors when creating a RESTMapper / ObjectTyper by
// returning those initialization errors when the interface methods are invoked. This defers the

                    try {
                        handler.execute(current);
                    } catch (Throwable e) {
                        current = new DefaultMultiCauseException("Error in unrecoverable error handler: " + handler, e, throwable);
                    }
                }
            }
        };
        this.hub = new MessageHub(completion.toString(), executorFactory, errorHandler);

	randState, randInc uint64

	// rawInMem is true if the region holds raw bytes, which occurs during
	// minimization. If true after the worker fails during minimization, this
	// indicates that an unrecoverable error occurred, and the region can be
	// used to retrieve the raw bytes that caused the error.
	rawInMem bool
}

// sharedMemSize returns the size needed for a shared memory buffer that can

	walkValues := []*Value{}
	for _, v := range b.Values {
		if v.Uses == 0 && v.removeable() {
			walkValues = append(walkValues, v)
		}
	}
	for len(walkValues) != 0 {
		v := walkValues[len(walkValues)-1]
		walkValues = walkValues[:len(walkValues)-1]
		if v.Uses == 0 && v.removeable() {
			walkValues = append(walkValues, v.Args...)
			v.reset(OpInvalid)
		}
	}
	return true
}