[buildscript] migrated BuildScriptDataBuilder's backend onto GradleBuildScriptBuilder

GitOrigin-RevId: 27407f5f290495121100c489384cde683548bda8
2026-02-05 08:06:56 +07:00 · 2021-04-06 15:50:43 +03:00
parent e5d478aeaf
commit 2eb4e1d1dc
23 changed files with 283 additions and 409 deletions
--- a/plugins/gradle/java/src/frameworkSupport/GradleGroovyFrameworkSupportProvider.java
+++ b/plugins/gradle/java/src/frameworkSupport/GradleGroovyFrameworkSupportProvider.java
@@ -51,13 +51,7 @@ public class GradleGroovyFrameworkSupportProvider extends GradleFrameworkSupport
                         @NotNull ModifiableModelsProvider modifiableModelsProvider,
                         @NotNull BuildScriptDataBuilder buildScriptData) {
    buildScriptData
-      .addPluginDefinitionInPluginsGroup("id 'groovy'")
-      .addRepositoriesDefinition("mavenCentral()")
-      .addOther("test {\n" +
-                "    useJUnitPlatform()\n" +
-                "}")
-      .addDependencyNotation("implementation 'org.codehaus.groovy:groovy-all:3.0.5'")
-      .addDependencyNotation("testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.0'")
-      .addDependencyNotation("testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'");
+      .withGroovyPlugin()
+      .withJUnit();
  }
 }
--- a/plugins/gradle/java/src/frameworkSupport/GradleJavaFrameworkSupportProvider.java
+++ b/plugins/gradle/java/src/frameworkSupport/GradleJavaFrameworkSupportProvider.java
@@ -51,12 +51,7 @@ public class GradleJavaFrameworkSupportProvider extends GradleFrameworkSupportPr
                         @NotNull ModifiableModelsProvider modifiableModelsProvider,
                         @NotNull BuildScriptDataBuilder buildScriptData) {
    buildScriptData
-      .addPluginDefinitionInPluginsGroup("id 'java'")
-      .addRepositoriesDefinition("mavenCentral()")
-      .addOther("test {\n" +
-                "    useJUnitPlatform()\n" +
-                "}")
-      .addDependencyNotation("testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'")
-      .addDependencyNotation("testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'");
+      .withJavaPlugin()
+      .withJUnit();
  }
 }
--- a/plugins/gradle/java/src/service/project/wizard/AbstractGradleModuleBuilder.java
+++ b/plugins/gradle/java/src/service/project/wizard/AbstractGradleModuleBuilder.java
@@ -54,7 +54,9 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.gradle.codeInspection.GradleInspectionBundle;
 import org.jetbrains.plugins.gradle.frameworkSupport.BuildScriptDataBuilder;
-import org.jetbrains.plugins.gradle.frameworkSupport.KotlinBuildScriptDataBuilder;
+import org.jetbrains.plugins.gradle.frameworkSupport.script.GroovyScriptBuilder;
+import org.jetbrains.plugins.gradle.frameworkSupport.script.KotlinScriptBuilder;
+import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptBuilder;
 import org.jetbrains.plugins.gradle.model.data.GradleSourceSetData;
 import org.jetbrains.plugins.gradle.service.execution.GradleExecutionUtil;
 import org.jetbrains.plugins.gradle.service.project.open.GradleProjectImportUtil;
@@ -167,15 +169,10 @@ public abstract class AbstractGradleModuleBuilder extends AbstractExternalModule
      myUseKotlinDSL
    );

-    BuildScriptDataBuilder builder;
-    if (myUseKotlinDSL) {
-      GradleProjectSettings gradleProjectSettings = getExternalProjectSettings();
-      GradleVersion version = gradleProjectSettings.resolveGradleVersion();
-      builder = new KotlinBuildScriptDataBuilder(gradleBuildFile, version);
-    }
-    else {
-      builder = new BuildScriptDataBuilder(gradleBuildFile);
-    }
+    GradleProjectSettings gradleProjectSettings = getExternalProjectSettings();
+    GradleVersion version = gradleProjectSettings.resolveGradleVersion();
+    ScriptBuilder scriptBuilder = myUseKotlinDSL ? new KotlinScriptBuilder() : new GroovyScriptBuilder();
+    BuildScriptDataBuilder builder = new BuildScriptDataBuilder(gradleBuildFile, scriptBuilder, version);
    modifiableRootModel.getModule().putUserData(BUILD_SCRIPT_DATA, builder);
  }

@@ -269,15 +266,8 @@ public abstract class AbstractGradleModuleBuilder extends AbstractExternalModule
    if (buildScriptDataBuilder == null) return null;
    try {
      VirtualFile buildScriptFile = buildScriptDataBuilder.getBuildScriptFile();
-      String lineSeparator = lineSeparator(buildScriptFile);
-      String imports = StringUtil.convertLineSeparators(buildScriptDataBuilder.buildImports(), lineSeparator);
-      String configurationPart = StringUtil.convertLineSeparators(buildScriptDataBuilder.buildConfigurationPart(), lineSeparator);
-      String existingText = StringUtil.trimTrailing(VfsUtilCore.loadText(buildScriptFile));
-      String content = (!imports.isEmpty() ? imports + lineSeparator : "") +
-                       (!configurationPart.isEmpty() ? configurationPart + lineSeparator : "") +
-                       (!existingText.isEmpty() ? existingText + lineSeparator : "") +
-                       lineSeparator +
-                       StringUtil.convertLineSeparators(buildScriptDataBuilder.buildMainPart(), lineSeparator);
+      buildScriptDataBuilder.addPrefix(StringUtil.trimTrailing(VfsUtilCore.loadText(buildScriptFile)));
+      String content = StringUtil.convertLineSeparators(buildScriptDataBuilder.generate(), lineSeparator(buildScriptFile));
      VfsUtil.saveText(buildScriptFile, content);
      return buildScriptFile;
    }
--- a/plugins/gradle/java/testSources/compiler/GradleJpsJavaCompilationTest.java
+++ b/plugins/gradle/java/testSources/compiler/GradleJpsJavaCompilationTest.java
@@ -2,11 +2,9 @@
 package org.jetbrains.plugins.gradle.compiler;

 import com.intellij.openapi.externalSystem.service.project.manage.ExternalProjectsManagerImpl;
-import org.jetbrains.plugins.gradle.frameworkSupport.script.GroovyScriptBuilder;
 import org.junit.Test;

 import java.io.IOException;
-import java.util.function.Consumer;

 public class GradleJpsJavaCompilationTest extends GradleJpsCompilingTestCase {
  @Test
@@ -40,12 +38,14 @@ public class GradleJpsJavaCompilationTest extends GradleJpsCompilingTestCase {
    importProject(
      createBuildScriptBuilder()
        .withJavaPlugin()
-        .withPrefix((Consumer<GroovyScriptBuilder>)it -> it
-          .assign("sourceCompatibility", "7")
-          .assign("targetCompatibility", "7")
-          .block("compileJava", (Consumer<GroovyScriptBuilder>)it1 -> it1
-            .assign("sourceCompatibility", "8")
-            .assign("targetCompatibility", "8")))
+        .withPrefix(it -> {
+          it.assign("sourceCompatibility", "7");
+          it.assign("targetCompatibility", "7");
+          it.call("compileJava", it1 -> {
+            it1.assign("sourceCompatibility", "8");
+            it1.assign("targetCompatibility", "8");
+          });
+        })
        .generate()
    );
    compileModules("project.main");
--- a/plugins/gradle/java/testSources/importing/GradleJavaCompilerSettingsImportingTestCase.kt
+++ b/plugins/gradle/java/testSources/importing/GradleJavaCompilerSettingsImportingTestCase.kt
@@ -3,6 +3,7 @@ package org.jetbrains.plugins.gradle.importing

 import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.plugins.gradle.frameworkSupport.script.GroovyScriptBuilder.Companion.groovy
+import org.jetbrains.plugins.gradle.importing.GradleBuildScriptBuilder.Companion.buildscript
 import org.jetbrains.plugins.gradle.tooling.builder.AbstractModelBuilderTest
 import org.junit.runners.Parameterized

--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/BuildScriptDataBuilder.kt
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/BuildScriptDataBuilder.kt
@@ -1,190 +1,60 @@
 // Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
-package org.jetbrains.plugins.gradle.frameworkSupport;
+package org.jetbrains.plugins.gradle.frameworkSupport

-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.util.Function;
-import com.intellij.util.SmartList;
-import com.intellij.util.containers.ContainerUtil;
-import org.gradle.util.GradleVersion;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.vfs.VirtualFile
+import org.gradle.util.GradleVersion
+import org.jetbrains.plugins.gradle.frameworkSupport.buildscript.AbstractGradleBuildScriptBuilder
+import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptBuilder
+import kotlin.apply as applyKt

-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-import java.util.TreeSet;
-import java.util.regex.Pattern;

-/**
- * @author Vladislav.Soroka
- */
-public class BuildScriptDataBuilder {
-  private final static Logger LOG = Logger.getInstance(BuildScriptDataBuilder.class);
+@Suppress("unused")
+class BuildScriptDataBuilder(
+  val buildScriptFile: VirtualFile,
+  override val scriptBuilder: ScriptBuilder,
+  gradleVersion: GradleVersion = GradleVersion.current()
+) : AbstractGradleBuildScriptBuilder<BuildScriptDataBuilder>(gradleVersion) {

-  @NotNull private final VirtualFile myBuildScriptFile;
-  protected final Set<String> imports = new TreeSet<>();
-  protected final Set<String> plugins = new TreeSet<>();
-  protected final Set<String> pluginsInGroup = new TreeSet<>();
-  protected final Set<String> repositories = new TreeSet<>();
-  protected final Set<String> dependencies = new TreeSet<>();
-  protected final Set<String> properties = new TreeSet<>();
-  protected final Set<String> buildScriptProperties = new TreeSet<>();
-  protected final Set<String> buildScriptRepositories = new TreeSet<>();
-  protected final Set<String> buildScriptDependencies = new TreeSet<>();
-  protected final Set<String> other = new TreeSet<>();
-  protected final GradleVersion myGradleVersion;
+  override fun apply(action: BuildScriptDataBuilder.() -> Unit) = applyKt(action)

-  public BuildScriptDataBuilder(@NotNull VirtualFile buildScriptFile) {
-    this(buildScriptFile, GradleVersion.current());
-  }
+  override fun addImport(import: String) =
+    super.addImport(import.trim().removePrefix("import "))

-  public BuildScriptDataBuilder(@NotNull VirtualFile buildScriptFile, @NotNull GradleVersion gradleVersion) {
-    myBuildScriptFile = buildScriptFile;
-    myGradleVersion = gradleVersion;
-  }
+  fun addBuildscriptPropertyDefinition(definition: String) =
+    addPrefix(definition.trim())

-  @NotNull
-  public VirtualFile getBuildScriptFile() {
-    return myBuildScriptFile;
-  }
+  fun addBuildscriptRepositoriesDefinition(definition: String) =
+    addBuildScriptRepository(definition.trim())

-  @NotNull
-  public GradleVersion getGradleVersion() {
-    return myGradleVersion;
-  }
+  fun addBuildscriptDependencyNotation(notation: String) =
+    addBuildScriptDependency(notation.trim())

-  public String buildImports() {
-    if (!imports.isEmpty()) {
-      return StringUtil.join(imports, "\n") + "\n";
-    }
+  fun addPluginDefinitionInPluginsGroup(definition: String) =
+    addPlugin(definition.trim())

-    return "";
-  }
+  fun addPluginDefinition(definition: String) =
+    addPrefix(definition.trim())

-  public String buildConfigurationPart() {
-    List<String> lines = new ArrayList<>();
-    addBuildscriptLines(lines, BuildScriptDataBuilder::padding);
-    if (!pluginsInGroup.isEmpty()) {
-      lines.add("plugins {");
-      lines.addAll(ContainerUtil.map(pluginsInGroup, BuildScriptDataBuilder::padding));
-      lines.add("}");
-      lines.add("");
-    }
-    return StringUtil.join(lines, "\n");
-  }
+  fun addRepositoriesDefinition(definition: String) =
+    addRepository(definition.trim())

-  public String buildMainPart() {
-    List<String> lines = new ArrayList<>();
-    addPluginsLines(lines, BuildScriptDataBuilder::padding);
-    if (!properties.isEmpty()) {
-      lines.addAll(properties);
-      lines.add("");
-    }
-    if (!repositories.isEmpty()) {
-      lines.add("repositories {");
-      lines.addAll(ContainerUtil.map(repositories, BuildScriptDataBuilder::padding));
-      lines.add("}");
-      lines.add("");
-    }
-    if (!dependencies.isEmpty()) {
-      lines.add("dependencies {");
-      lines.addAll(ContainerUtil.map(dependencies, BuildScriptDataBuilder::padding));
-      lines.add("}");
-      lines.add("");
-    }
-    if (!other.isEmpty()) {
-      lines.addAll(other);
-    }
-    return StringUtil.join(lines, "\n");
-  }
-
-  protected void addPluginsLines(@NotNull List<? super String> lines, @NotNull Function<? super String, String> padding) {
-    if (!plugins.isEmpty()) {
-      lines.addAll(plugins);
-      lines.add("");
-    }
-  }
-
-  private void addBuildscriptLines(@NotNull List<? super String> lines, @NotNull Function<? super String, String> padding) {
-    if (!buildScriptRepositories.isEmpty() || !buildScriptDependencies.isEmpty() || !buildScriptProperties.isEmpty()) {
-      lines.add("buildscript {");
-      final List<String> buildScriptLines = new SmartList<>();
-      if (!buildScriptProperties.isEmpty()) {
-        buildScriptLines.addAll(buildScriptProperties);
-        buildScriptLines.add("");
-      }
-      if (!buildScriptRepositories.isEmpty()) {
-        buildScriptLines.add("repositories {");
-        buildScriptLines.addAll(ContainerUtil.map(buildScriptRepositories, padding));
-        buildScriptLines.add("}");
-      }
-      if (!buildScriptDependencies.isEmpty()) {
-        buildScriptLines.add("dependencies {");
-        buildScriptLines.addAll(ContainerUtil.map(buildScriptDependencies, padding));
-        buildScriptLines.add("}");
-      }
-      lines.addAll(ContainerUtil.map(buildScriptLines, padding));
-      lines.add("}");
-      lines.add("");
-    }
-  }
-
-  public BuildScriptDataBuilder addImport(@NonNls @NotNull String importString) {
-    imports.add(importString);
-    return this;
-  }
-
-  public BuildScriptDataBuilder addBuildscriptPropertyDefinition(@NonNls @NotNull String definition) {
-    buildScriptProperties.add(definition.trim());
-    return this;
-  }
-
-  public BuildScriptDataBuilder addBuildscriptRepositoriesDefinition(@NonNls @NotNull String definition) {
-    buildScriptRepositories.add(definition.trim());
-    return this;
-  }
-
-  public BuildScriptDataBuilder addBuildscriptDependencyNotation(@NonNls @NotNull String notation) {
-    buildScriptDependencies.add(notation.trim());
-    return this;
-  }
-
-  public BuildScriptDataBuilder addPluginDefinitionInPluginsGroup(@NonNls @NotNull String definition) {
-    pluginsInGroup.add(definition.trim());
-    return this;
-  }
-
-  public BuildScriptDataBuilder addPluginDefinition(@NonNls @NotNull String definition) {
-    plugins.add(definition.trim());
-    return this;
-  }
-
-  public BuildScriptDataBuilder addRepositoriesDefinition(@NonNls @NotNull String definition) {
-    repositories.add(definition.trim());
-    return this;
-  }
-
-  public BuildScriptDataBuilder addDependencyNotation(@NonNls @NotNull String notation) {
-    if (notation.matches("\\s*(compile|testCompile|runtime|testRuntime)[^\\w].*")) {
-      LOG.warn(notation);
+  fun addDependencyNotation(notation: String) = apply {
+    if (notation.matches("\\s*(compile|testCompile|runtime|testRuntime)[^\\w].*".toRegex())) {
+      LOG.warn(notation)
      LOG.warn("compile, testCompile, runtime and testRuntime dependency notations were deprecated in Gradle 3.4, " +
-               "use implementation, api, compileOnly and runtimeOnly instead", new Throwable());
+               "use implementation, api, compileOnly and runtimeOnly instead", Throwable())
    }
-    dependencies.add(notation.trim());
-    return this;
+    addDependency(notation.trim())
  }

-  public BuildScriptDataBuilder addPropertyDefinition(@NonNls @NotNull String definition) {
-    properties.add(definition.trim());
-    return this;
-  }
+  fun addPropertyDefinition(definition: String) =
+    addPrefix(definition.trim())

-  public BuildScriptDataBuilder addOther(@NonNls @NotNull String definition) {
-    other.add(definition.trim());
-    return this;
-  }
+  fun addOther(definition: String) =
+    addPostfix(definition.trim())

-  private static String padding(@NonNls String s) {return StringUtil.isNotEmpty(s) ? "    " + s : "";}
-}
+  companion object {
+    private val LOG = Logger.getInstance(BuildScriptDataBuilder::class.java)
+  }
+}
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/KotlinBuildScriptDataBuilder.kt
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/KotlinBuildScriptDataBuilder.kt
@@ -1,22 +0,0 @@
-// Copyright 2000-2017 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
-package org.jetbrains.plugins.gradle.frameworkSupport
-
-import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.util.Function
-import org.gradle.util.GradleVersion
-
-class KotlinBuildScriptDataBuilder : BuildScriptDataBuilder {
-  constructor(buildScriptFile: VirtualFile) : super(buildScriptFile)
-
-  constructor(buildScriptFile: VirtualFile, gradleVersion: GradleVersion) : super(buildScriptFile, gradleVersion)
-
-  override fun addPluginsLines(lines: MutableList<in String>, padding: Function<in String, String>) {
-    if (plugins.isEmpty()) {
-      return
-    }
-    lines.add("apply {")
-    lines.addAll(plugins.map { padding.`fun`(it) })
-    lines.add("}")
-    lines.add("")
-  }
-}
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/buildscript/AbstractGradleBuildScriptBuilder.kt
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/buildscript/AbstractGradleBuildScriptBuilder.kt
@@ -1,17 +1,20 @@
 // Copyright 2000-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 package org.jetbrains.plugins.gradle.frameworkSupport.buildscript

-import com.intellij.openapi.util.Version
-import com.intellij.openapi.util.io.FileUtil
+import com.intellij.openapi.util.io.FileUtil.toSystemIndependentName
 import org.gradle.util.GradleVersion
 import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElement.Statement.Expression
-import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptTreeBuilder
 import java.io.File

-@Suppress("unused")
-abstract class AbstractGradleBuildScriptBuilder<BSB : AbstractGradleBuildScriptBuilder<BSB>>(
-  private val gradleVersion: GradleVersion
-) : AbstractGradleBuildScriptBuilderCore<BSB>(), GradleBuildScriptBuilder<BSB> {
+@Suppress("MemberVisibilityCanBePrivate", "unused")
+abstract class AbstractGradleBuildScriptBuilder<BSB : GradleBuildScriptBuilder<BSB>>(
+  gradleVersion: GradleVersion
+) : AbstractGradleBuildScriptBuilderCore<BSB>(gradleVersion), GradleBuildScriptBuilder<BSB> {
+
+  val kotlinVersion = if (isSupportedKotlin4(gradleVersion)) "1.4.32" else "1.3.50"
+  val groovyVersion = "3.0.5"
+  val junit4Version = "4.12"
+  val junit5Version = "5.7.0"

  override fun addGroup(group: String) =
    withPrefix { assign("group", group) }
@@ -25,34 +28,34 @@ abstract class AbstractGradleBuildScriptBuilder<BSB : AbstractGradleBuildScriptB
  override fun addDependency(scope: String, dependency: Expression) =
    withDependency { call(scope, dependency) }

+  private fun dependencyScope(sourceSet: String?, scope: String) =
+    when (sourceSet) {
+      null -> scope
+      else -> sourceSet + scope.capitalize()
+    }
+
+  override fun addApiDependency(dependency: String, sourceSet: String?) =
+    addApiDependency(string(dependency), sourceSet)
+
+  override fun addApiDependency(dependency: Expression, sourceSet: String?) =
+    addDependency(dependencyScope(sourceSet, "api"), dependency)
+
  override fun addImplementationDependency(dependency: String, sourceSet: String?) =
    addImplementationDependency(string(dependency), sourceSet)

  override fun addImplementationDependency(dependency: Expression, sourceSet: String?) =
-    when (sourceSet) {
-      null -> when (isSupportedImplementationScope(gradleVersion)) {
-        true -> addDependency("implementation", dependency)
-        else -> addDependency("compile", dependency)
-      }
-      else -> when (isSupportedImplementationScope(gradleVersion)) {
-        true -> addDependency("${sourceSet}Implementation", dependency)
-        else -> addDependency("${sourceSet}Compile", dependency)
-      }
+    when (isSupportedImplementationScope(gradleVersion)) {
+      true -> addDependency(dependencyScope(sourceSet, "implementation"), dependency)
+      else -> addDependency(dependencyScope(sourceSet, "compile"), dependency)
    }

  override fun addRuntimeOnlyDependency(dependency: String, sourceSet: String?) =
    addRuntimeOnlyDependency(string(dependency), sourceSet)

  override fun addRuntimeOnlyDependency(dependency: Expression, sourceSet: String?) =
-    when (sourceSet) {
-      null -> when (isSupportedRuntimeOnlyScope(gradleVersion)) {
-        true -> addDependency("runtimeOnly", dependency)
-        else -> addDependency("runtime", dependency)
-      }
-      else -> when (isSupportedRuntimeOnlyScope(gradleVersion)) {
-        true -> addDependency("${sourceSet}RuntimeOnly", dependency)
-        else -> addDependency("${sourceSet}Runtime", dependency)
-      }
+    when (isSupportedRuntimeOnlyScope(gradleVersion)) {
+      true -> addDependency(dependencyScope(sourceSet, "runtimeOnly"), dependency)
+      else -> addDependency(dependencyScope(sourceSet, "runtime"), dependency)
    }

  override fun addTestImplementationDependency(dependency: String) =
@@ -73,47 +76,52 @@ abstract class AbstractGradleBuildScriptBuilder<BSB : AbstractGradleBuildScriptB
  override fun addBuildScriptClasspath(dependency: Expression) =
    withBuildScriptDependency { call("classpath", dependency) }

-  override fun withBuildScriptMavenCentral(useOldStyleMetadata: Boolean) =
+  override fun addBuildScriptClasspath(vararg dependencies: File) =
+    addBuildScriptClasspath(call("files", dependencies.map { it.absolutePath }.map(::toSystemIndependentName).map(::argument)))
+
+  override fun withBuildScriptMavenCentral() =
    withBuildScriptRepository {
-      mavenCentralRepository(useOldStyleMetadata)
+      call("mavenCentral")
    }

-  override fun withMavenCentral(useOldStyleMetadata: Boolean) =
+  override fun withMavenCentral() =
    withRepository {
-      mavenCentralRepository(useOldStyleMetadata)
+      call("mavenCentral")
    }

-  private fun ScriptTreeBuilder.mavenCentralRepository(useOldStyleMetadata: Boolean = false) {
-    call("maven") {
-      call("url", "https://repo.labs.intellij.net/repo1")
-      if (useOldStyleMetadata) {
-        call("metadataSources") {
-          call("mavenPom")
-          call("artifact")
-        }
-      }
+  override fun withPlugin(id: String, version: String?) = withPlugin {
+    when (version) {
+      null -> call("id", id)
+      else -> infixCall(call("id", id), "version", string(version))
    }
  }

-  override fun withJavaPlugin() = applyPlugin("java")
+  override fun withJavaPlugin() =
+    withPlugin("java")

-  override fun withIdeaPlugin() = applyPlugin("idea")
+  override fun withJavaLibraryPlugin() =
+    withPlugin("java-library")

-  override fun withKotlinPlugin(version: String) = apply {
-    withBuildScriptPrefix { assign("ext.kotlin_version", version) }
-    withBuildScriptMavenCentral()
-    addBuildScriptClasspath("org.jetbrains.kotlin:kotlin-gradle-plugin:${'$'}kotlin_version")
-    applyPlugin("kotlin")
-  }
+  override fun withIdeaPlugin() =
+    withPlugin("idea")
+
+  override fun withKotlinJvmPlugin() =
+    withPlugin("org.jetbrains.kotlin.jvm", kotlinVersion)
+
+  override fun withKotlinJsPlugin() =
+    withPlugin("org.jetbrains.kotlin.js", kotlinVersion)
+
+  override fun withKotlinMultiplatformPlugin() =
+    withPlugin("org.jetbrains.kotlin.multiplatform", kotlinVersion)

  override fun withGroovyPlugin() = apply {
-    applyPlugin("groovy")
+    withPlugin("groovy")
    withMavenCentral()
-    addImplementationDependency("org.codehaus.groovy:groovy-all:3.0.5")
+    addImplementationDependency("org.codehaus.groovy:groovy-all:$groovyVersion")
  }

  override fun withApplicationPlugin(mainClassName: String) = apply {
-    applyPlugin("application")
+    withPlugin("application")
    withPostfix { assign("mainClassName", mainClassName) }
  }

@@ -124,14 +132,14 @@ abstract class AbstractGradleBuildScriptBuilder<BSB : AbstractGradleBuildScriptB

  override fun withJUnit4() = apply {
    withMavenCentral()
-    addTestImplementationDependency("junit:junit:4.12")
+    addTestImplementationDependency("junit:junit:$junit4Version")
  }

  override fun withJUnit5() = apply {
    assert(isSupportedJUnit5(gradleVersion))
    withMavenCentral()
-    addTestImplementationDependency("org.junit.jupiter:junit-jupiter-api:5.7.0")
-    addTestRuntimeOnlyDependency("org.junit.jupiter:junit-jupiter-engine:5.7.0")
+    addTestImplementationDependency("org.junit.jupiter:junit-jupiter-api:$junit5Version")
+    addTestRuntimeOnlyDependency("org.junit.jupiter:junit-jupiter-engine:$junit5Version")
    withPostfix {
      call("test") {
        call("useJUnitPlatform")
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/buildscript/AbstractGradleBuildScriptBuilderCore.kt
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/buildscript/AbstractGradleBuildScriptBuilderCore.kt
@@ -1,6 +1,7 @@
 // Copyright 2000-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 package org.jetbrains.plugins.gradle.frameworkSupport.buildscript

+import org.gradle.util.GradleVersion
 import org.jetbrains.plugins.gradle.frameworkSupport.script.AbstractScriptElementBuilder
 import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptBuilder
 import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptTreeBuilder
@@ -8,8 +9,9 @@ import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptTreeBuilder.Co
 import java.util.function.Consumer

@Suppress("unused")
-abstract class AbstractGradleBuildScriptBuilderCore<BSB : AbstractGradleBuildScriptBuilderCore<BSB>>
-  : GradleBuildScriptBuilderCore<BSB>, AbstractScriptElementBuilder() {
+abstract class AbstractGradleBuildScriptBuilderCore<BSB : GradleBuildScriptBuilderCore<BSB>>(
+  override val gradleVersion: GradleVersion
+) : GradleBuildScriptBuilderCore<BSB>, AbstractScriptElementBuilder() {

  private val imports = ScriptTreeBuilder()
  private val buildScriptPrefixes = ScriptTreeBuilder()
@@ -17,7 +19,6 @@ abstract class AbstractGradleBuildScriptBuilderCore<BSB : AbstractGradleBuildScr
  private val buildScriptRepositories = ScriptTreeBuilder()
  private val buildScriptPostfixes = ScriptTreeBuilder()
  private val plugins = ScriptTreeBuilder()
-  private val applicablePlugins = ScriptTreeBuilder()
  private val prefixes = ScriptTreeBuilder()
  private val dependencies = ScriptTreeBuilder()
  private val repositories = ScriptTreeBuilder()
@@ -27,70 +28,58 @@ abstract class AbstractGradleBuildScriptBuilderCore<BSB : AbstractGradleBuildScr

  protected abstract fun apply(action: BSB.() -> Unit): BSB

-  private fun apply(builder: ScriptTreeBuilder, configure: ScriptTreeBuilder.() -> Unit) = apply { builder.configure() }
-  private fun applyIfNotContains(builder: ScriptTreeBuilder, configure: ScriptTreeBuilder.() -> Unit) = apply {
-    val childBuilder = ScriptTreeBuilder(configure)
-    if (childBuilder !in builder) {
-      builder.join(childBuilder)
-    }
-  }
+  private fun applyAndMerge(builder: ScriptTreeBuilder, configure: ScriptTreeBuilder.() -> Unit) =
+    apply { builder.addNonExistedElements(configure) }

-  override fun addImport(import: String) = applyIfNotContains(imports) { code("import $import") }
+  override fun addImport(import: String) = applyAndMerge(imports) { code("import $import") }

  override fun addBuildScriptPrefix(vararg prefix: String) = withBuildScriptPrefix { code(*prefix) }
-  override fun withBuildScriptPrefix(configure: ScriptTreeBuilder.() -> Unit) = apply(buildScriptPrefixes, configure)
+  override fun withBuildScriptPrefix(configure: ScriptTreeBuilder.() -> Unit) = applyAndMerge(buildScriptPrefixes, configure)
  override fun withBuildScriptPrefix(configure: Consumer<ScriptTreeBuilder>) = withBuildScriptPrefix(configure::accept)

  override fun addBuildScriptDependency(dependency: String) = withBuildScriptDependency { code(dependency) }
-  override fun withBuildScriptDependency(configure: ScriptTreeBuilder.() -> Unit) = applyIfNotContains(buildScriptDependencies, configure)
+  override fun withBuildScriptDependency(configure: ScriptTreeBuilder.() -> Unit) = applyAndMerge(buildScriptDependencies, configure)
  override fun withBuildScriptDependency(configure: Consumer<ScriptTreeBuilder>) = withBuildScriptDependency(configure::accept)

  override fun addBuildScriptRepository(repository: String) = withBuildScriptRepository { code(repository) }
-  override fun withBuildScriptRepository(configure: ScriptTreeBuilder.() -> Unit) = applyIfNotContains(buildScriptRepositories, configure)
+  override fun withBuildScriptRepository(configure: ScriptTreeBuilder.() -> Unit) = applyAndMerge(buildScriptRepositories, configure)
  override fun withBuildScriptRepository(configure: Consumer<ScriptTreeBuilder>) = withBuildScriptRepository(configure::accept)

  override fun addBuildScriptPostfix(vararg postfix: String) = withBuildScriptPostfix { code(*postfix) }
-  override fun withBuildScriptPostfix(configure: ScriptTreeBuilder.() -> Unit) = apply(buildScriptPostfixes, configure)
+  override fun withBuildScriptPostfix(configure: ScriptTreeBuilder.() -> Unit) = applyAndMerge(buildScriptPostfixes, configure)
  override fun withBuildScriptPostfix(configure: Consumer<ScriptTreeBuilder>) = withBuildScriptPostfix(configure::accept)

-  override fun addPlugin(id: String, version: String?) = applyIfNotContains(plugins) {
-    when (version) {
-      null -> call("id", id)
-      else -> infixCall(call("id", id), "version", string(version))
-    }
-  }
-
-  override fun applyPlugin(plugin: String) = applyIfNotContains(applicablePlugins) { call("apply", "plugin" to plugin) }
+  override fun addPlugin(plugin: String) = withPlugin { code(plugin) }
+  override fun withPlugin(configure: ScriptTreeBuilder.() -> Unit) = applyAndMerge(plugins, configure)

  override fun addPrefix(vararg prefix: String) = withPrefix { code(*prefix) }
-  override fun withPrefix(configure: ScriptTreeBuilder.() -> Unit) = apply(prefixes, configure)
+  override fun withPrefix(configure: ScriptTreeBuilder.() -> Unit) = applyAndMerge(prefixes, configure)
  override fun withPrefix(configure: Consumer<ScriptTreeBuilder>) = withPrefix(configure::accept)

  override fun addDependency(dependency: String) = withDependency { code(dependency) }
-  override fun withDependency(configure: ScriptTreeBuilder.() -> Unit) = applyIfNotContains(dependencies, configure)
+  override fun withDependency(configure: ScriptTreeBuilder.() -> Unit) = applyAndMerge(dependencies, configure)
  override fun withDependency(configure: Consumer<ScriptTreeBuilder>) = withDependency(configure::accept)

  override fun addRepository(repository: String) = withRepository { code(repository) }
-  override fun withRepository(configure: ScriptTreeBuilder.() -> Unit) = applyIfNotContains(repositories, configure)
+  override fun withRepository(configure: ScriptTreeBuilder.() -> Unit) = applyAndMerge(repositories, configure)
  override fun withRepository(configure: Consumer<ScriptTreeBuilder>) = withRepository(configure::accept)

  override fun addPostfix(vararg postfix: String) = withPostfix { code(*postfix) }
-  override fun withPostfix(configure: ScriptTreeBuilder.() -> Unit) = apply(postfixes, configure)
+  override fun withPostfix(configure: ScriptTreeBuilder.() -> Unit) = applyAndMerge(postfixes, configure)
  override fun withPostfix(configure: Consumer<ScriptTreeBuilder>) = withPostfix(configure::accept)

  override fun generate() = script(scriptBuilder) {
-    join(imports)
+    join(imports).ln()
    callIfNotEmpty("buildscript") {
-      join(buildScriptPrefixes)
-      callIfNotEmpty("repositories", buildScriptRepositories)
-      callIfNotEmpty("dependencies", buildScriptDependencies)
-      join(buildScriptPostfixes)
-    }
-    callIfNotEmpty("plugins", plugins)
-    join(applicablePlugins)
-    join(prefixes)
-    callIfNotEmpty("repositories", repositories)
-    callIfNotEmpty("dependencies", dependencies)
-    join(postfixes)
+      join(buildScriptPrefixes).ln()
+      callIfNotEmpty("repositories", buildScriptRepositories).ln()
+      callIfNotEmpty("dependencies", buildScriptDependencies).ln()
+      join(buildScriptPostfixes).ln()
+    }.ln()
+    callIfNotEmpty("plugins", plugins).ln()
+    join(prefixes).ln()
+    callIfNotEmpty("repositories", repositories).ln()
+    callIfNotEmpty("dependencies", dependencies).ln()
+    join(postfixes).ln()
  }
 }
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/buildscript/GradleBuildScriptBuilder.kt
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/buildscript/GradleBuildScriptBuilder.kt
@@ -2,7 +2,6 @@
 package org.jetbrains.plugins.gradle.frameworkSupport.buildscript

 import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElement.Statement.Expression
-import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptTreeBuilder
 import java.io.File

@Suppress("unused")
@@ -14,6 +13,9 @@ interface GradleBuildScriptBuilder<BSB : GradleBuildScriptBuilder<BSB>> : Gradle
  fun addDependency(scope: String, dependency: String): BSB
  fun addDependency(scope: String, dependency: Expression): BSB

+  fun addApiDependency(dependency: String, sourceSet: String? = null): BSB
+  fun addApiDependency(dependency: Expression, sourceSet: String? = null): BSB
+
  fun addImplementationDependency(dependency: String, sourceSet: String? = null): BSB
  fun addImplementationDependency(dependency: Expression, sourceSet: String? = null): BSB

@@ -28,24 +30,23 @@ interface GradleBuildScriptBuilder<BSB : GradleBuildScriptBuilder<BSB>> : Gradle

  fun addBuildScriptClasspath(dependency: String): BSB
  fun addBuildScriptClasspath(dependency: Expression): BSB
+  fun addBuildScriptClasspath(vararg dependencies: File): BSB

-  fun withBuildScriptMavenCentral(useOldStyleMetadata: Boolean = false): BSB
+  fun withMavenCentral(): BSB
+  fun withBuildScriptMavenCentral(): BSB

-  fun withMavenCentral(useOldStyleMetadata: Boolean = false): BSB
+  fun withPlugin(id: String, version: String? = null): BSB

  fun withJavaPlugin(): BSB
-
+  fun withJavaLibraryPlugin(): BSB
  fun withIdeaPlugin(): BSB
-
-  fun withKotlinPlugin(version: String): BSB
-
+  fun withKotlinJvmPlugin(): BSB
+  fun withKotlinJsPlugin(): BSB
+  fun withKotlinMultiplatformPlugin(): BSB
  fun withGroovyPlugin(): BSB
-
  fun withApplicationPlugin(mainClassName: String): BSB

  fun withJUnit(): BSB
-
  fun withJUnit4(): BSB
-
  fun withJUnit5(): BSB
 }
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/buildscript/GradleBuildScriptBuilderCore.kt
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/buildscript/GradleBuildScriptBuilderCore.kt
@@ -1,12 +1,16 @@
 // Copyright 2000-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 package org.jetbrains.plugins.gradle.frameworkSupport.buildscript

+import org.gradle.util.GradleVersion
 import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElementBuilder
 import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptTreeBuilder
 import java.util.function.Consumer

@Suppress("unused")
-interface GradleBuildScriptBuilderCore<BSB : GradleBuildScriptBuilderCore<BSB>> : ScriptElementBuilder {
+interface GradleBuildScriptBuilderCore<out BSB : GradleBuildScriptBuilderCore<BSB>> : ScriptElementBuilder {
+
+  val gradleVersion: GradleVersion
+
  /**
   * ...
   * import [import]
@@ -68,20 +72,15 @@ interface GradleBuildScriptBuilderCore<BSB : GradleBuildScriptBuilderCore<BSB>>
  fun withBuildScriptPostfix(configure: ScriptTreeBuilder.() -> Unit): BSB
  fun withBuildScriptPostfix(configure: Consumer<ScriptTreeBuilder>): BSB

+
  /**
   * plugins {
   *   ...
-   *   groovy: id '[id]' version '[version]'
-   *   kotlin: id("[id]") version "[version]"
+   *   [plugin]
   * }
   */
-  fun addPlugin(id: String, version: String? = null): BSB
-
-  /**
-   * groovy: apply plugin: '[plugin]'
-   * kotlin: apply(plugin = "[plugin]")
-   */
-  fun applyPlugin(plugin: String): BSB
+  fun addPlugin(plugin: String): BSB
+  fun withPlugin(configure: ScriptTreeBuilder.() -> Unit): BSB

  /**
   * buildscript { ... }
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/buildscript/GradleBuildScriptBuilderUtil.kt
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/buildscript/GradleBuildScriptBuilderUtil.kt
@@ -17,3 +17,7 @@ fun isSupportedRuntimeOnlyScope(gradleVersion: GradleVersion): Boolean {
 fun isSupportedJUnit5(gradleVersion: GradleVersion): Boolean {
  return gradleVersion.baseVersion >= GradleVersion.version("4.7")
 }
+
+fun isSupportedKotlin4(gradleVersion: GradleVersion): Boolean {
+  return gradleVersion.baseVersion >= GradleVersion.version("5.6.2")
+}
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/buildscript/GroovyGradleBuildScriptBuilder.kt
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/buildscript/GroovyGradleBuildScriptBuilder.kt
@@ -1,15 +0,0 @@
-// Copyright 2000-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
-package org.jetbrains.plugins.gradle.frameworkSupport.buildscript
-
-import org.gradle.util.GradleVersion
-import org.jetbrains.plugins.gradle.frameworkSupport.script.GroovyScriptBuilder
-import kotlin.apply as applyKt
-
-class GroovyGradleBuildScriptBuilder(
-  gradleVersion: GradleVersion
-) : AbstractGradleBuildScriptBuilder<GroovyGradleBuildScriptBuilder>(gradleVersion) {
-
-  override val scriptBuilder = GroovyScriptBuilder()
-
-  override fun apply(action: GroovyGradleBuildScriptBuilder.() -> Unit) = applyKt(action)
-}
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/buildscript/KotlinGradleBuildScriptBuilder.kt
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/buildscript/KotlinGradleBuildScriptBuilder.kt
@@ -1,15 +0,0 @@
-// Copyright 2000-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
-package org.jetbrains.plugins.gradle.frameworkSupport.buildscript
-
-import org.gradle.util.GradleVersion
-import org.jetbrains.plugins.gradle.frameworkSupport.script.KotlinScriptBuilder
-import kotlin.apply as applyKt
-
-class KotlinGradleBuildScriptBuilder(
-  gradleVersion: GradleVersion
-) : AbstractGradleBuildScriptBuilder<KotlinGradleBuildScriptBuilder>(gradleVersion) {
-
-  override val scriptBuilder = KotlinScriptBuilder()
-
-  override fun apply(action: KotlinGradleBuildScriptBuilder.() -> Unit) = applyKt(action)
-}
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/script/AbstractScriptBuilder.kt
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/script/AbstractScriptBuilder.kt
@@ -2,9 +2,8 @@
 package org.jetbrains.plugins.gradle.frameworkSupport.script

 import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElement.ArgumentElement
-import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElement.Statement.AssignElement
+import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElement.Statement.*
 import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElement.Statement.Expression.*
-import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElement.Statement.PlusAssignElement
 import java.util.*

 abstract class AbstractScriptBuilder : ScriptBuilder {
@@ -61,8 +60,8 @@ abstract class AbstractScriptBuilder : ScriptBuilder {
        }
      }
      is CodeElement -> {
-        for ((i, line) in element.text.withIndex()) {
-          add(line, indent, i == 0 && isNewLine)
+        for (line in element.text) {
+          add(line, indent, isNewLine)
        }
      }
      is InfixCall -> {
@@ -75,6 +74,9 @@ abstract class AbstractScriptBuilder : ScriptBuilder {
      is StringElement -> {
        add(""""${element.value}"""", indent, isNewLine)
      }
+      NewLineElement -> {
+        add("", indent, isNewLine)
+      }
    }
  }

@@ -89,7 +91,12 @@ abstract class AbstractScriptBuilder : ScriptBuilder {

  protected fun add(code: String, indent: Int, isNewLine: Boolean) {
    if (isNewLine || lines.isEmpty()) {
-      lines.add("    ".repeat(indent) + code)
+      if (code.isBlank()) {
+        lines.add(code)
+      }
+      else {
+        lines.add("    ".repeat(indent) + code)
+      }
    }
    else {
      lines[lines.lastIndex] += code
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/script/AbstractScriptElementBuilder.kt
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/script/AbstractScriptElementBuilder.kt
@@ -5,10 +5,14 @@ import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElement.Argume
 import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElement.Statement.*
 import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElement.Statement.Expression.*
 import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptTreeBuilder.Companion.tree
+import java.util.function.Consumer

@Suppress("MemberVisibilityCanBePrivate", "unused")
 abstract class AbstractScriptElementBuilder : ScriptElementBuilder {

+  override fun newLine() = NewLineElement
+  override fun ScriptElement?.ln() = if (this == null || this is BlockElement && isEmpty()) null else newLine()
+
  override fun string(value: String) = StringElement(value)

  override fun code(text: List<String>) = CodeElement(text)
@@ -27,6 +31,7 @@ abstract class AbstractScriptElementBuilder : ScriptElementBuilder {
    call(name, arguments + argument(configure))

  override fun call(name: String) = call(name, emptyList())
+  override fun call(name: String, configure: Consumer<ScriptTreeBuilder>) = call(name, configure::accept)
  override fun call(name: String, configure: ScriptTreeBuilder.() -> Unit) =
    call(name, emptyList(), configure)

--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/script/ScriptElement.kt
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/script/ScriptElement.kt
@@ -5,6 +5,7 @@ package org.jetbrains.plugins.gradle.frameworkSupport.script
 sealed class ScriptElement {
  data class ArgumentElement(val name: String?, val value: Statement.Expression) : ScriptElement()
  sealed class Statement : ScriptElement() {
+    object NewLineElement : Statement()
    data class AssignElement(val name: String, val value: Expression) : Statement()
    data class PlusAssignElement(val name: String, val value: Expression) : Statement()
    sealed class Expression : Statement() {
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/script/ScriptElementBuilder.kt
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/script/ScriptElementBuilder.kt
@@ -4,10 +4,14 @@ package org.jetbrains.plugins.gradle.frameworkSupport.script
 import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElement.ArgumentElement
 import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElement.Statement.*
 import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElement.Statement.Expression.*
+import java.util.function.Consumer

@Suppress("unused")
 interface ScriptElementBuilder {

+  fun newLine(): NewLineElement
+  fun ScriptElement?.ln(): NewLineElement?
+
  fun string(value: String): StringElement

  fun code(text: List<String>): CodeElement
@@ -25,6 +29,7 @@ interface ScriptElementBuilder {
  fun call(name: String, arguments: List<ArgumentElement>, configure: ScriptTreeBuilder.() -> Unit): CallElement

  fun call(name: String): CallElement
+  fun call(name: String, configure: Consumer<ScriptTreeBuilder>): CallElement
  fun call(name: String, configure: ScriptTreeBuilder.() -> Unit): CallElement

  fun call(name: String, vararg arguments: ArgumentElement): CallElement
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/script/ScriptTreeBuilder.kt
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/frameworkSupport/script/ScriptTreeBuilder.kt
@@ -6,15 +6,25 @@ import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElement.Argume
 import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElement.Statement
 import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElement.Statement.Expression
 import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElement.Statement.Expression.BlockElement
+import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptElement.Statement.NewLineElement

@Suppress("MemberVisibilityCanBePrivate", "unused")
 class ScriptTreeBuilder : AbstractScriptElementBuilder() {

  private val roots = ArrayList<ScriptElement>()

-  operator fun contains(builder: ScriptTreeBuilder) = roots.containsAll(builder.generate().statements)
+  fun join(builder: ScriptTreeBuilder) = builder.generate().apply {
+    roots.addAll(statements)
+  }

-  fun join(builder: ScriptTreeBuilder) = roots.addAll(builder.generate().statements)
+  fun addNonExistedElements(configure: ScriptTreeBuilder.() -> Unit) = addNonExistedElements(ScriptTreeBuilder(configure))
+  fun addNonExistedElements(builder: ScriptTreeBuilder) = builder.generate().apply {
+    for (statement in statements) {
+      if (statement !in roots) {
+        roots.add(statement)
+      }
+    }
+  }

  private fun <E : ScriptElement> process(vararg children: ScriptElement, element: () -> E) = process(children.toList(), element)
  private fun <E : ScriptElement> process(children: List<ScriptElement>, createElement: () -> E): E {
@@ -26,6 +36,7 @@ class ScriptTreeBuilder : AbstractScriptElementBuilder() {
    return element
  }

+  override fun newLine() = process { super.newLine() }
  override fun string(value: String) = process { super.string(value) }
  override fun code(text: List<String>) = process { super.code(text) }
  override fun assign(name: String, value: Expression) = process(value) { super.assign(name, value) }
@@ -41,7 +52,7 @@ class ScriptTreeBuilder : AbstractScriptElementBuilder() {
      LOG.error("Found non complete script tree. Orphan elements: " +
                roots.filterNot { it is Statement })
    }
-    return BlockElement(statements)
+    return BlockElement(statements.dropLastWhile { it == NewLineElement })
  }

  companion object {
--- a/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/GradleBuildScriptBuilder.kt
+++ b/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/GradleBuildScriptBuilder.kt
@@ -2,7 +2,6 @@
 package org.jetbrains.plugins.gradle.importing

 import com.intellij.openapi.util.Version
-import com.intellij.openapi.util.io.FileUtil
 import org.gradle.util.GradleVersion
 import org.jetbrains.plugins.gradle.frameworkSupport.buildscript.AbstractGradleBuildScriptBuilder
 import org.jetbrains.plugins.gradle.frameworkSupport.script.GroovyScriptBuilder
@@ -10,11 +9,15 @@ import org.jetbrains.plugins.gradle.frameworkSupport.script.ScriptTreeBuilder
 import java.io.File
 import kotlin.apply as applyKt

+@Suppress("MemberVisibilityCanBePrivate", "unused")
 class GradleBuildScriptBuilder(gradleVersion: GradleVersion) : AbstractGradleBuildScriptBuilder<GradleBuildScriptBuilder>(gradleVersion) {
  override val scriptBuilder = GroovyScriptBuilder()

  override fun apply(action: GradleBuildScriptBuilder.() -> Unit) = applyKt(action)

+  fun applyPlugin(plugin: String) =
+    withPrefix { call("apply", argument("plugin", code(plugin))) }
+
  fun withTask(name: String, type: String? = null, configure: ScriptTreeBuilder.() -> Unit = {}) =
    withPostfix {
      when (type) {
@@ -38,16 +41,43 @@ class GradleBuildScriptBuilder(gradleVersion: GradleVersion) : AbstractGradleBui
    withLocalGradleIdeaExtPlugin(jarFile)
  }

-  fun withGradleIdeaExtPlugin() = apply {
-    addPlugin("org.jetbrains.gradle.plugin.idea-ext", IDEA_EXT_PLUGIN_VERSION)
-  }
+  fun withGradleIdeaExtPlugin() =
+    withPlugin("org.jetbrains.gradle.plugin.idea-ext", IDEA_EXT_PLUGIN_VERSION)

  fun withLocalGradleIdeaExtPlugin(jarFile: File) = apply {
    withBuildScriptMavenCentral()
-    addBuildScriptClasspath(call("files", FileUtil.toSystemIndependentName(jarFile.absolutePath)))
+    addBuildScriptClasspath(jarFile)
    addBuildScriptClasspath("com.google.code.gson:gson:2.8.2")
    addBuildScriptClasspath("com.google.guava:guava:25.1-jre")
-    applyPlugin("org.jetbrains.gradle.plugin.idea-ext")
+    applyPlugin("'org.jetbrains.gradle.plugin.idea-ext'")
+  }
+
+  override fun withBuildScriptMavenCentral() =
+    withBuildScriptMavenCentral(false)
+
+  override fun withMavenCentral() =
+    withMavenCentral(false)
+
+  fun withBuildScriptMavenCentral(useOldStyleMetadata: Boolean) =
+    withBuildScriptRepository {
+      mavenCentralRepository(useOldStyleMetadata)
+    }
+
+  fun withMavenCentral(useOldStyleMetadata: Boolean) =
+    withRepository {
+      mavenCentralRepository(useOldStyleMetadata)
+    }
+
+  private fun ScriptTreeBuilder.mavenCentralRepository(useOldStyleMetadata: Boolean = false) {
+    call("maven") {
+      call("url", "https://repo.labs.intellij.net/repo1")
+      if (useOldStyleMetadata) {
+        call("metadataSources") {
+          call("mavenPom")
+          call("artifact")
+        }
+      }
+    }
  }

  companion object {
--- a/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/GradleBuildScriptBuilderTest.kt
+++ b/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/GradleBuildScriptBuilderTest.kt
@@ -19,26 +19,29 @@ class GradleBuildScriptBuilderTest {
    assertThat(buildscript(GradleVersion.current()) {
      addImport("org.example.Class1")
      addImport("org.example.Class2")
-      addPlugin("plugin-id")
+      withPlugin("plugin-id")
      addRepository("repositoryCentral()")
      addDependency("dependency", "my-dependency-id")
-      addPrefix("")
      withPrefix { call("println", "Hello, Prefix!") }
      withPostfix { call("println", call("hello", code("postfix"))) }
    }).isEqualTo("""
      import org.example.Class1
      import org.example.Class2
+      
      plugins {
          id 'plugin-id'
      }
      
      println 'Hello, Prefix!'
+      
      repositories {
          repositoryCentral()
      }
+      
      dependencies {
          dependency 'my-dependency-id'
      }
+      
      println hello(postfix)
    """.trimIndent())
  }
@@ -50,7 +53,7 @@ class GradleBuildScriptBuilderTest {
      withBuildScriptRepository { call("repo", code("file('build/repo')")) }
      withBuildScriptDependency { call("classpath", code("file('build/targets/org/classpath/archive.jar')")) }
      addBuildScriptPostfix("println 'Hello, Postfix!'")
-      applyPlugin("gradle-build")
+      applyPlugin("'gradle-build'")
      addImport("org.classpath.Build")
      withPrefix {
        call("Build.configureSuperGradleBuild") {
@@ -59,16 +62,21 @@ class GradleBuildScriptBuilderTest {
      }
    }).isEqualTo("""
      import org.classpath.Build
+      
      buildscript {
          println 'Hello, Prefix!'
+      
          repositories {
              repo file('build/repo')
          }
+      
          dependencies {
              classpath file('build/targets/org/classpath/archive.jar')
          }
+      
          println 'Hello, Postfix!'
      }
+      
      apply plugin: 'gradle-build'
      Build.configureSuperGradleBuild {
          makeBeautiful()
@@ -79,21 +87,27 @@ class GradleBuildScriptBuilderTest {
  @Test
  fun `test build script deduplication`() {
    assertThat(buildscript(GradleVersion.current()) {
+      withJUnit()
      withJUnit()
      withGroovyPlugin()
      withGroovyPlugin()
    }).isEqualTo("""
-      apply plugin: 'groovy'
+      plugins {
+          id 'groovy'
+      }
+      
      repositories {
          maven {
              url 'https://repo.labs.intellij.net/repo1'
          }
      }
+      
      dependencies {
          testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
          testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
          implementation 'org.codehaus.groovy:groovy-all:3.0.5'
      }
+      
      test {
          useJUnitPlatform()
      }
@@ -114,12 +128,14 @@ class GradleBuildScriptBuilderTest {
                url 'https://repo.labs.intellij.net/repo1'
            }
        }
+        
        dependencies {
            testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
            testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
            implementation 'my-dep'
            runtimeOnly my-runtime-dep
        }
+        
        test {
            useJUnitPlatform()
        }
@@ -131,6 +147,7 @@ class GradleBuildScriptBuilderTest {
                url 'https://repo.labs.intellij.net/repo1'
            }
        }
+        
        dependencies {
            testCompile 'junit:junit:4.12'
            compile 'my-dep'
@@ -144,6 +161,7 @@ class GradleBuildScriptBuilderTest {
                url 'https://repo.labs.intellij.net/repo1'
            }
        }
+        
        dependencies {
            testImplementation 'junit:junit:4.12'
            implementation 'my-dep'
--- a/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/GradleCompositeImportingTest.java
+++ b/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/GradleCompositeImportingTest.java
@@ -393,22 +393,20 @@ public class GradleCompositeImportingTest extends GradleImportingTestCase {

    createProjectSubFile("project-a/core/build.gradle",
                         createBuildScriptBuilder()
-                           .withKotlinPlugin("1.3.50")
-                           .addRepository(" maven { url 'https://repo.labs.intellij.net/repo1' }")
-                           .addPrefix("apply plugin: 'java-library'").generate());
+                           .withMavenCentral()
+                           .withKotlinJvmPlugin()
+                           .withJavaLibraryPlugin()
+                           .generate());

    createProjectSubFile("project-a/ext/build.gradle",
                         createBuildScriptBuilder()
-                           .withKotlinPlugin("1.3.50")
-                           .addRepository(" maven { url 'https://repo.labs.intellij.net/repo1' }")
-                           .addPrefix(
-                             "apply plugin: 'java-library'",
-                             "group = 'myGroup.projectA'",
-                             "version = '1.0-SNAPSHOT'",
-                             "dependencies {",
-                             " api project(':core')",
-                             "}"
-                         ).generate());
+                           .withMavenCentral()
+                           .withKotlinJvmPlugin()
+                           .withJavaLibraryPlugin()
+                           .addGroup("myGroup.projectA")
+                           .addVersion("1.0-SNAPSHOT")
+                           .addDependency("api project(':core')")
+                           .generate());

    createProjectSubFile("project-a/build.gradle", "");

--- a/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/GradleSettingsImportingTest.java
+++ b/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/GradleSettingsImportingTest.java
@@ -631,7 +631,7 @@ public class GradleSettingsImportingTest extends GradleSettingsImportingTestCase
      createBuildScriptBuilder()
        .withGradleIdeaExtPlugin()
        .withJavaPlugin()
-        .withKotlinPlugin("1.3.50")
+        .withKotlinJvmPlugin()
        .addPostfix("idea {")
        .addPostfix("  module {")
        .addPostfix("    settings {")
@@ -665,7 +665,7 @@ public class GradleSettingsImportingTest extends GradleSettingsImportingTestCase
      createBuildScriptBuilder()
        .withGradleIdeaExtPlugin()
        .withJavaPlugin()
-        .withKotlinPlugin("1.3.50")
+        .withKotlinJvmPlugin()
        .addPostfix("idea {")
        .addPostfix("  module {")
        .addPostfix("    settings {")