parent.setNChildren(1);
                parent.addChild(0, node);
            }

            parent = node;
        }
        return tree;
    }

    public void setClasspath(List<ArtifactMetadata> classpath) {
        this.classpath = classpath;
    }

    public ArtifactScopeEnum getScope() {
        return scope;
    }

    public void setScope(ArtifactScopeEnum scope) {

  val bundleExtension =
    jarTask.extensions.create(
      BundleTaskExtension.NAME,
      BundleTaskExtension::class.java,
      jarTask,
    )
  bundleExtension.run {
    setClasspath(osgi.compileClasspath + sourceSets["main"].compileClasspath)
    properties.empty()
    bnd(*bndProperties)
  }
  jarTask.doLast(
    "buildBundle",

                .filter(f -> f.getName().endsWith(".java"))
                .filter(new DeduplicatePackageInfoFiles())
            );

            task.setClasspath(extension.getClasspath());

            // TODO: This should be in Javadoc task
            DirectoryProperty generatedJavadocDirectory = project.getObjects().directoryProperty();

        builder.setJar(bundleJar)

        val validClasspath = classpath.filter { it.exists() && (it.isDirectory || isZip(it)) }
        builder.setProperty("project.buildpath", validClasspath.asPath)
        builder.setClasspath(validClasspath.files.toTypedArray())

        val validSourcepath = sourcepath.filter { it.exists() }
        builder.setProperty("project.sourcepath", validSourcepath.asPath)

        assertNotNull(res, "null classpath container after runtime transform");
        assertNotNull(res.getClasspath(), "null classpath after runtime transform");
        assertEquals(4, res.getClasspath().size(), "runtime classpath should have 4 entries");

        ArtifactMetadata md = res.getClasspath().get(3);
        assertEquals("1.1", md.getVersion(), "runtime artifact version should be 1.1");
    }

            spec.getSourceRoots().from(runtimeExtensions.flatMap(GradleKotlinDslRuntimeGeneratedSources::getGeneratedSources));
            spec.getClasspath().from(extension.getClasspath());
            spec.getClasspath().from(runtimeExtensions.flatMap(GradleKotlinDslRuntimeGeneratedSources::getGeneratedClasses));
            spec.getIncludes().from(extension.getSourceRoot().file("kotlin/Module.md"));

            return new MetadataGraph(getTree(), true, true);
        }
        return null;
    }
    // ----------------------------------------------------------------------------
    public ClasspathContainer getClasspath(ArtifactScopeEnum scope)
            throws MetadataGraphTransformationException, MetadataResolutionException {
        if (classpathTransformation == null) {
            return null;
        }

     */
    public abstract ConfigurableFileCollection getKotlinDslSource();

    /**
     * The runtime classpath of the source code to be documented.
     */
    public abstract ConfigurableFileCollection getClasspath();

    /**
     * A working directory to be used to stage documentation as its generated.
     * All of the sections of the documentation have working directories off of this one.
     */

    @PathSensitive(PathSensitivity.NONE)
    @InputFile
    abstract RegularFileProperty getStylesheetHighlightFile();

    @Classpath
    abstract ConfigurableFileCollection getClasspath();

    @OutputDirectory
    abstract DirectoryProperty getDestinationDirectory();

    @Inject
    abstract WorkerLeaseService getWorkerLeaseService();

    @Inject
    abstract ObjectFactory getObjects()

        });
        sourcesPath.setCanBeConsumed(false);
        sourcesPath.setCanBeResolved(true);
        sourcesPath.extendsFrom(runtimeClasspath);

        extension.getClasspath().from(runtimeClasspath);
        extension.getSourceRoots().from(sourcesPath.getIncoming().artifactView(v -> v.lenient(true)).getFiles());