element.setTextContent(normalise(element.getTextContent()))
        }
    }

    static String normalise(String content) {
        content.replace('\t', '    ').stripIndent().replace('\r\n', '\n')
    }

    def transformApiLinks(Document doc) {
        ClassMetaDataRepository<ClassLinkMetaData> linkRepository = new SimpleClassMetaDataRepository<ClassLinkMetaData>()

    inputs.property("jvmOpts", jvmOpts)
    doLast {
        val optsEnvVar = "DEFAULT_JVM_OPTS"
        scriptFile.writeText(scriptFile.readText().replace("$optsEnvVar='", "$optsEnvVar='$jvmOpts "))
        batchScript.writeText(batchScript.readText().replace("set $optsEnvVar=", "set $optsEnvVar=$jvmOpts "))
    }
}

fun Project.wrapperUpdateTask(name: String, label: String) {
    val wrapperTaskName = "${name}Wrapper"

            Element linkElement = document.createElement("ulink");
            linkElement.setAttribute("url", String.format("https://docs.oracle.com/javase/%s/docs/api/%s.html", javaVersion,
                    className.replace(".", "/")));
            Element classNameElement = document.createElement("classname");
            classNameElement.appendChild(document.createTextNode(StringUtils.substringAfterLast(className, ".")));

errorproneExtension.disabledChecks.addAll(
    // DISCUSS
    "EqualsGetClass", // Let's agree if we want to adopt Error Prone's idea of valid equals()
    "JdkObsolete", // Most of the checks are good, but we do not want to replace all LinkedLists without a good reason

    // NEVER
    "MissingSummary", // We have another mechanism to check Javadocs on public API
    "InjectOnConstructorOfAbstractClass", // We use abstract injection as a pattern

        performanceTests.forEach { performanceTestTrigger ->
            // The space removal is necessary - otherwise it doesn't show
            val artifactDirName = performanceTestTrigger.name.replace(" ", "")
            performancePartialTrigger.dependencies {
                artifacts(performanceTestTrigger) {

                    getAllErrorCorrections().forEach((correction) => {
                        correction.acceptation = reason;
                        result.acceptedApiChanges.push(correction);
                    });
                    // Sort the array in place by type, then member

            .withTemplate(templateFolder.template("$templateFragment.adoc"))
            .withTarget(settings.target.file("../README.adoc").asFile)
            .withBinding("language", descriptor.language.toString().replace("C++", "{cpp}"))
            .withBinding("languageLC", descriptor.language.getName().toLowerCase())
            .withBinding("languageExtension", descriptor.language.extension)

        "void" -> "Unit"
        "?" -> "*"
        in mappedTypeStrings.keys -> mappedTypeStrings[binaryName]!!
        in primitiveTypeStrings.keys -> primitiveTypeStrings[binaryName]!!
        else -> binaryName.replace('$', '.')
    }


/**
 * See https://kotlinlang.org/docs/reference/java-interop.html#mapped-types
 */
private
val mappedTypeStrings =
    mapOf(
        // Built-ins

            parent.appendChild(caution);
            Element para = document.createElement("para");
            caution.appendChild(para);
            para.appendChild(document.createTextNode(String.format("Note: This %s has been replaced by %s.", type, elementDoc.getReplacement())));
        }
    }

     * The base docs CSS to embed in the HTML
     */
    @InputFile
    @PathSensitive(PathSensitivity.NONE)
    public abstract RegularFileProperty getBaseCssFile();

    /**
     * Key-value pairs that are replaced in the generated HTML.
     *
     * This uses Ant style replacement tokens.
     */
    @Input
    public abstract MapProperty<String, String> getReplacementTokens();

    @Inject