import org.gradle.buildinit.plugins.internal.modifiers.ModularizationOption
import org.gradle.work.DisableCachingByDefault
import javax.inject.Inject


@DisableCachingByDefault(because = "Not worth caching")
abstract class GenerateSample : DefaultTask() {

    @get:Input
    abstract val type: Property<String>

    @get:Input
    abstract val modularization: Property<ModularizationOption>

	// and
	//	#define A #define B (x) x
	// The first definition of B has an argument, the second doesn't. Because we let
	// text/scanner strip the blanks for us, this is extremely rare, hard to fix, and not worth it.
	return s.pos
}

func (s *Slice) Close() {

[[sec:declaring-capabilities-external-modules]]
== Declaring capabilities for external modules

It's worth noting that Gradle supports declaring capabilities for components you build, but also for external components in case they didn't.

For example, if your build file contains the following dependencies:

            return null;
        }
    }

    public static boolean tryInstall() {
        // Installing the same transformer multiple times is very problematic, so additional correctness check is worth it.
        if (!INSTALLED.compareAndSet(false, true)) {
            throw new IllegalStateException("The transformer is already installed in " + DefaultClassFileTransformer.class.getClassLoader());
        }

import org.gradle.api.tasks.Internal
import org.gradle.api.tasks.TaskAction
import org.gradle.util.GradleVersion
import org.gradle.work.DisableCachingByDefault
import java.io.File


@DisableCachingByDefault(because = "Not worth caching")
abstract class UpdateReleasedVersions : DefaultTask() {

    @get:Internal
    abstract val releasedVersionsFile: RegularFileProperty

    @get:Internal

/**
 * Generates or updates the Gradle Daemon JVM criteria.
 *
 * This controls the version of the JVM required to run the Gradle Daemon.
 *
 * @since 8.8
 */
@DisableCachingByDefault(because = "Not worth caching")
@Incubating
public abstract class UpdateDaemonJvm extends DefaultTask {
    /**
     * Constructor.
     *
     * @since 8.8
     */
    @Inject
    public UpdateDaemonJvm() {

    }

 * between the styled elements. The tag names correspond to a {@link StyledTextOutput.Style}
 * name.</p>
 * <p>For example: This is an &lt;Failure&gt;error&lt;/Failure&gt;</p>
 * <p>It's worth noting that {@link #getMessage()} would return a non-rendered text,
 * so that tooling using the exception messages are not concerned with rendering issues.
 * </p>
 */
public class StyledException extends GradleException {

import java.util.Map;
import java.util.Properties;
import java.util.stream.Collectors;

/**
 * Generates plugin descriptors from plugin declarations.
 */
@DisableCachingByDefault(because = "Not worth caching")
public abstract class GeneratePluginDescriptors extends DefaultTask {

    private final ListProperty<PluginDeclaration> declarations;
    private final Provider<Map<String, String>> implementationClassById;

  Four score and seven years ago our fathers brought forth on
this continent, a new nation, conceived in Liberty, and dedicated
to the proposition that all men are created equal.
  Now we are engaged in a great Civil War, testing whether that
nation, or any nation so conceived and so dedicated, can long
endure.
  We are met on a great battle-field of that war.
  We have come to dedicate a portion of that field, as a final

import java.util.Properties
import javax.xml.parsers.DocumentBuilderFactory


/**
 * Fetch the latest Kotlin versions and write a properties file.
 * Never up-to-date, non-cacheable.
 */
@UntrackedTask(because = "Not worth tracking")
abstract class UpdateKotlinVersions : DefaultTask() {

    @get:Internal
    abstract val comment: Property<String>

    @get:Internal
    abstract val minimumSupported: Property<String>