inspectParametersNullabilityOf(ctor.oldConstructor.get(), ctor.newConstructor.get())

        } else if (member instanceof JApiMethod) {

            JApiMethod method = (JApiMethod) member
            CtMethod oldMethod = method.oldMethod.get()
            CtMethod newMethod = method.newMethod.get()

            inspectParametersNullabilityOf(oldMethod, newMethod)

            });

            // TODO: This breaks the provider
            task.setSourceDir(extension.getUserManual().getStagedDocumentation().get().getAsFile());
            // TODO: This breaks the provider
            task.setOutputDir(extension.getUserManual().getStagingRoot().dir("render-multi").get().getAsFile());

            Map<String, Object> attributes = new HashMap<>();
            attributes.put("icons", "font");

            }
        }.files)
        this.manifestFile = moduleIdentity.baseName.map { layout.buildDirectory.file("generated-resources/$it-classpath/$it-classpath.properties").get() }
    }
    sourceSets["main"].output.dir(classpathManifest.map { it.manifestFile.get().asFile.parentFile })
}

/**
 * Walk the resolved graph and discover all external dependencies that are not transitive dependencies

    @Override
    public void execute(ViolationCheckContext context) {
        List<UpgradedProperty> currentUpgradedProperties = UpgradedProperties.parse(params.get(CURRENT_UPGRADED_PROPERTIES_KEY));
        List<UpgradedProperty> baselineUpgradedProperties = UpgradedProperties.parse(params.get(BASELINE_UPGRADED_PROPERTIES_KEY));
        context.putUserData(CURRENT_ACCESSORS_OF_UPGRADED_PROPERTIES, diff(

            if (!isInBuildLogic) { // BuildScanExtension is only available in the gradle project
                val buildScan = gradleRootProject.extensions.findByType<BuildScanConfiguration>()
                val infoCollectedInBuildLogic = gradleRootProject.extensions.extraProperties.get("collectedInfo-${klass.simpleName}-build-logic")!!

        });
    });

    Object.values(fileMetadatas).forEach(fileMetadata => {
        [...fileOwners.keys()].forEach(platform => {
            const files = fileOwners.get(platform);
            if (files.includes(fileMetadata.file)) {
                result.get(platform).files.push(fileMetadata.file);
            }
        });
    });

    console.log("categorize: ");
    console.log([...result.values()]);
    return result;

        DeploymentRegistry registry = getDeploymentRegistry();
        JavaApplicationHandle handle = registry.get(getPath(), JavaApplicationHandle.class);
        if (handle == null) {
            JavaExecHandleBuilder builder = getExecActionFactory().newJavaExec();
            builder.setExecutable(getJavaLauncher().get().getExecutablePath().getAsFile());

Most platforms typically build on the features of other platforms.

By understanding the Gradle platforms and their relationships, you can get a feel for where in the Gradle source a particular feature might be implemented.

See [Gradle platform architecture](platforms.md) for a list of the platforms and more details.

## Gradle runtimes

        }
    }

    private void wrapContentInContainer(Document document) {
        // Wrap the page in a text container to get the margins
        Elements bodyContent = document.body().children().remove();
        document.body().prepend("<div class='container'/>");
        document.body().children().get(0).html(bodyContent.outerHtml());
    }

    private void addTOC(Document document) {

    @InputArtifact
    abstract Provider<FileSystemLocation> getArtifact()

    @Override
    void transform(TransformOutputs outputs) {
        File baselineJarsDirectory = artifact.get().asFile
        if (baselineJarsDirectory.name == 'gradle-jars') {
            baselineJarsDirectory.listFiles().each {
                outputs.file(it)
            }
        }
    }