TaskContainer tasks = project.getTasks();
        ObjectFactory objects = project.getObjects();
        ProviderFactory providers = project.getProviders();

        GradleDocumentationExtension extension = project.getExtensions().create("gradleDocumentation", GradleDocumentationExtension.class);
        applyConventions(project, tasks, objects, layout, extension);

    @Override
    public void apply(Project project) {
        ProjectLayout layout = project.getLayout();
        TaskContainer tasks = project.getTasks();

        GradleDocumentationExtension extension = project.getExtensions().getByType(GradleDocumentationExtension.class);
        generateDefaultImports(project, tasks, extension);
        generateUserManual(project, tasks, layout, extension);

    private static final String TASK_NAME = "dokkatooGeneratePublicationHtml";

    @Override
    public void apply(Project project) {
        GradleDocumentationExtension documentationExtension = project.getExtensions().getByType(GradleDocumentationExtension.class);
        applyPlugin(project);
        updateDocumentationExtension(project, documentationExtension);
        configurePlugin(project, documentationExtension);
    }

) : AnalysisHandlerExtension {
    internal companion object {
        fun getInstance(area: AreaInstance, module: KtModule): KtFe10AnalysisHandlerExtension {
            val extensions = AnalysisHandlerExtension.extensionPointName.getExtensions(area)
                .filterIsInstance<KtFe10AnalysisHandlerExtension>()
            return extensions.firstOrNull { it.useSiteModule == module }
                ?: extensions.singleOrNull { it.useSiteModule == null }

        List<Plugin> extensionPlugins = new ArrayList<>();

        Build build = model.getBuild();

        if (build != null) {
            for (Extension extension : build.getExtensions()) {
                Plugin plugin = new Plugin();
                plugin.setGroupId(extension.getGroupId());
                plugin.setArtifactId(extension.getArtifactId());

    }

    public List<Extension> getBuildExtensions() {
        Build build = getBuild();
        if ((build == null) || (build.getExtensions() == null)) {
            return Collections.emptyList();
        } else {
            return Collections.unmodifiableList(build.getExtensions());
        }
    }

    public void addProjectReference(MavenProject project) {
        projectReferences.put(

            // extensionArtifacts
            Set<Artifact> extensionArtifacts = new HashSet<>();
            List<Extension> extensions =
                    project.getModel().getDelegate().getBuild().getExtensions();
            if (extensions != null) {
                for (Extension ext : extensions) {
                    String version;
                    if (ext.getVersion() == null || ext.getVersion().isEmpty()) {

                            EMPTY,
                            problems,
                            errOn30,
                            Version.V20,
                            p.getExtensions(),
                            p.getKey(),
                            p);

                    validate20EffectivePluginDependencies(problems, p, request);
                }

    public boolean isExtensions() {
        return (getExtensions() != null) ? Boolean.parseBoolean(getExtensions()) : false;
    }
            ]]>
          </code>
        </codeSegment>
        <codeSegment>
          <version>4.0.0/4.0.99</version>
          <code>
            <![CDATA[
    public void setExtensions(boolean extensions) {
        setExtensions(String.valueOf(extensions));
    }

    /**

    }

    @Override
    public Version getBaseVersion() {
        return session.parseVersion(artifact.getBaseVersion());
    }

    @Nonnull
    @Override
    public String getExtension() {
        return artifact.getExtension();
    }

    @Nonnull
    @Override
    public String getClassifier() {
        return artifact.getClassifier();
    }

    @Override
    public boolean isSnapshot() {