import org.gradle.api.GradleException;
import org.gradle.api.Incubating;
import org.gradle.internal.exceptions.Contextual;
import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;

/**
 * Thrown when a model rule, or source of model rules, is declared in an invalid way.
 */
@Incubating
@Contextual
public class InvalidModelRuleDeclarationException extends GradleException {

 */

package org.gradle.api.resources;

import org.gradle.api.GradleException;
import org.gradle.internal.exceptions.Contextual;

import javax.annotation.Nullable;
import java.net.URI;

/**
 * Generic resource exception that all other resource-related exceptions inherit from.
 */
@Contextual
public class ResourceException extends GradleException {
    private final URI location;

    public ResourceException() {

 * limitations under the License.
 */

package org.gradle.model;

import org.gradle.api.GradleException;
import org.gradle.api.Incubating;
import org.gradle.internal.exceptions.Contextual;
import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;

/**
 * Thrown when there is a problem with the usage of a model rule.
 * <p>

 * limitations under the License.
 */

package org.gradle.model.internal.manage.schema.extract;

import org.gradle.internal.exceptions.Contextual;
import org.gradle.model.internal.type.ModelType;

import java.util.Deque;
import java.util.LinkedList;

@Contextual
public class InvalidManagedModelElementTypeException extends RuntimeException {

import org.gradle.api.logging.Logger;
import org.gradle.api.logging.Logging;
import org.gradle.internal.component.resolution.failure.type.ResolutionFailure;
import org.gradle.internal.exceptions.Contextual;
import org.gradle.internal.exceptions.ResolutionProvider;
import org.gradle.internal.exceptions.StyledException;

import javax.annotation.Nullable;
import java.util.List;

/**

 */

package org.gradle.internal.deprecation;

import org.apache.commons.lang.StringUtils;
import org.gradle.api.GradleException;
import org.gradle.api.problems.internal.DocLink;
import org.gradle.internal.exceptions.Contextual;

import javax.annotation.CheckReturnValue;
import javax.annotation.Nullable;

public class DocumentedFailure {
    public static Builder builder() {
        return new Builder();
    }

 * The [contextualModule] is the module which contains the symbols to be provided, if applicable. The declaration provider may use the
 * contextual module to provide declarations differently, such as providing alternative declarations for an outsider module. Some
 * functionality such as package set computation may also depend on the contextual module, as the declaration provider may require
 * additional information not available in the [scope].
 */

    }

    def "retains @Contextual annotation on placeholder"() {
        def notOk = new ContextualExceptionWithNonSerializableField("broken 2", new RuntimeException("broken 3"))

        when:
        def transported = transport(notOk)

        then:
        transported instanceof ContextualPlaceholderException
        transported.class.getAnnotation(Contextual) != null
        looksLike(notOk, transported)

abstract class AbstractDanglingFileSealedInheritorsTest : AbstractSealedInheritorsTest() {
    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val ktPsiFactory = KtPsiFactory.contextual(mainFile, markGenerated = true, eventSystemEnabled = false)
        val fakeKtFile = ktPsiFactory.createFile("fake.kt", mainFile.text)

        doTestByKtFile(fakeKtFile, testServices)
    }

// errors may be sent to a remote server for analysis. The context is used to
// determine how to log the error.
//
// If contextual logging is enabled, the default log output is equivalent to
//
//	logr.FromContext(ctx).WithName("UnhandledError").Error(err, msg, keysAndValues...)
//
// Without contextual logging, it is equivalent to:
//
//	klog.ErrorS(err, msg, keysAndValues...)
//