import org.gradle.internal.Factory;

/**
 * A specialized version of multi cause exception that is cheaper to create
 * because we avoid to fill a stack trace, and the message MUST be generated lazily.
 */
@Contextual
public class DefaultMultiCauseExceptionNoStackTrace extends DefaultMultiCauseException {
    public DefaultMultiCauseExceptionNoStackTrace(Factory<String> messageFactory) {
        super(messageFactory);
    }

 * limitations under the License.
 */

package org.gradle.internal.component.resolution.failure.type;

/**
 * Represents a specific type of failure that can occur during dependency resolution and
 * contains contextual information specific to that type of failure.
 *
 * @implSpec Extending types should be immutable data classes with no nullable fields, they
 * must also be serializable by the configuration cache.
 */

defined in the docs for ErrorCode.

HTML templates treat data values as plain text which should be encoded so they
can be safely embedded in an HTML document. The escaping is contextual, so
actions can appear within JavaScript, CSS, and URI contexts.

The security model used by this package assumes that template authors are
trusted, while Execute's data parameter is not. More details are
provided below.

     * The cache policy of a repository
     *
     * @return the cache policy
     */
    CachePolicy getCachePolicy();

    /**
     * Provides an injecting instantiator, giving access to services potentially contextual to a repository.
     *
     * @return a injecting instantiator
     */
    Instantiator getInjectingInstantiator();

    /**
     * Returns the problem definition.
     *
     * @return the definition
     * @since 8.9
     */
    ProblemDefinition getDefinition();

    /**
     * Returns the contextual label.
     *
     * @return the problem label
     * @since 8.9
     */
    ContextualLabel getContextualLabel();

    /**
     * Returns the details string.
     *
     * @return the problem details

        when:
        def commandLineExecution = factory.convert([option])
        commandLineExecution.execute(executionListener)

        then:
        outputs.stdOut.contains('To see help contextual to the project, use gradle help')
        outputs.stdOut.contains('USAGE: gradle [option...] [task...]')
        outputs.stdOut.contains('--help')
        outputs.stdOut.contains('--some-option')

        and:

        when:
        DeprecationLogger.deprecate("Something").withAdvice("Advice.").withContext("Contextual advice.").willBeRemovedInGradle9().undocumented().nagUser()

        then:
        expectMessage "Something has been deprecated. This is scheduled to be removed in Gradle ${NEXT_GRADLE_VERSION}. Contextual advice. Advice."
    }

    def "logs deprecated build invocation message"() {
        when:

import org.gradle.internal.deprecation.DeprecationLogger;

import java.util.Collections;

/**
 * An {@link AbstractRoleBasedConfigurationCreationRequest} that does not provide any additional contextual
 * information about the request, and emits generic error messages.
 */
public final class NoContextRoleBasedConfigurationCreationRequest extends AbstractRoleBasedConfigurationCreationRequest {

	//   pipeline output in Go 1.8 and earlier.
	//
	//   In most cases, such as the given example, this error can be resolved by
	//   simply removing the predefined escaper from the pipeline and letting the
	//   contextual autoescaper handle the escaping of the pipeline. In other
	//   instances, where the predefined escaper occurs in the middle of a
	//   pipeline where subsequent commands expect escaped input, e.g.

        testServices: TestServices
    ): Collection<ResolveTestCaseContext<KtReference?>> {
        val caretPositions = testServices.expressionMarkerProvider.getAllCarets(mainFile)

        val ktPsiFactory = KtPsiFactory.contextual(mainFile, markGenerated = true, eventSystemEnabled = true)
        val fakeKtFile = ktPsiFactory.createFile("fake.kt", mainFile.text)

        if (mainModule.testModule.directives.contains(Directives.COPY_RESOLUTION_MODE)) {