IDEA-313445 extracted Gradle Groovy and init scripts utils

GitOrigin-RevId: 0404c4f06220c12a18f7362eca47412694c6277e
2026-09-27 10:03:11 +07:00 · 2023-03-10 15:46:07 +00:00
parent a427c9d235
commit 035df172f3
12 changed files with 190 additions and 225 deletions
@@ -30,8 +30,8 @@ import org.jetbrains.annotations.NotNull
 import org.jetbrains.concurrency.AsyncPromise
 import org.jetbrains.concurrency.Promise
 import org.jetbrains.plugins.gradle.execution.target.GradleServerEnvironmentSetup.Companion.targetJavaExecutablePathMappingKey
-import org.jetbrains.plugins.gradle.service.execution.GradleExecutionHelper.toGroovyString
 import org.jetbrains.plugins.gradle.service.execution.GradleServerConfigurationProvider
+import org.jetbrains.plugins.gradle.service.execution.toGroovyString
 import org.jetbrains.plugins.gradle.settings.GradleSettings
 import org.jetbrains.plugins.gradle.tooling.proxy.Main
 import org.jetbrains.plugins.gradle.tooling.proxy.TargetBuildParameters
@@ -173,11 +173,11 @@ internal class GradleServerEnvironmentSetupImpl(private val project: Project,
    for (localPath in localPathsToMap) {
      if (targetPathMapper != null && targetPathMapper.canReplaceLocal(localPath)) {
        val targetPath = targetPathMapper.convertToRemote(localPath)
-        mapperInitScript.append("ext.pathMapper.put(${toGroovyString(localPath)}, ${toGroovyString(targetPath)})\n")
+        mapperInitScript.append("ext.pathMapper.put(${localPath.toGroovyString()}, ${targetPath.toGroovyString()})\n")
      }
      else if (pathMappingSettings.canReplaceLocal(localPath)) {
        val targetPath = pathMappingSettings.convertToRemote(localPath)
-        mapperInitScript.append("ext.pathMapper.put(${toGroovyString(localPath)}, ${toGroovyString(targetPath)})\n")
+        mapperInitScript.append("ext.pathMapper.put(${localPath.toGroovyString()}, ${targetPath.toGroovyString()})\n")
      }
    }

@@ -188,7 +188,7 @@ internal class GradleServerEnvironmentSetupImpl(private val project: Project,
    if (javaRuntime != null) {
      val targetJavaExecutablePath = arrayOf(javaRuntime.homePath, "bin", java).joinToString(platform.fileSeparator.toString())
      mapperInitScript.append(
-        "ext.pathMapper.put(\"${targetJavaExecutablePathMappingKey}\", ${toGroovyString(targetJavaExecutablePath)})\n")
+        "ext.pathMapper.put(\"${targetJavaExecutablePathMappingKey}\", ${targetJavaExecutablePath.toGroovyString()})\n")
    }
    else {
      mapperInitScript.append("ext.pathMapper.put(\"${targetJavaExecutablePathMappingKey}\", \"${java}\")\n")
@@ -244,7 +244,7 @@ internal class GradleServerEnvironmentSetupImpl(private val project: Project,
        if (file.extension != GradleConstants.EXTENSION) continue
        if (file.name.startsWith("ijinit")) {
          val fileContent = loadFile(file, CharsetToolkit.UTF8, true)
-          // based on the format of the `/org/jetbrains/plugins/gradle/tooling/internal/init/init.gradle` file
+          // based on the format of the `/org/jetbrains/plugins/gradle/tooling/internal/init/Init.gradle` file
          val toolingExtensionsPaths = fileContent
            .substringAfter(
              "initscript {\n" +
@@ -21,7 +21,6 @@ import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.util.Couple;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.io.FileUtilRt;
-import com.intellij.openapi.util.io.StreamUtil;
 import com.intellij.openapi.util.registry.Registry;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.VfsUtil;
@@ -41,32 +40,27 @@ import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.plugins.gradle.properties.models.Property;
 import org.jetbrains.plugins.gradle.properties.GradleProperties;
 import org.jetbrains.plugins.gradle.properties.GradlePropertiesFile;
+import org.jetbrains.plugins.gradle.properties.models.Property;
 import org.jetbrains.plugins.gradle.service.execution.cmd.GradleCommandLineOptionsProvider;
 import org.jetbrains.plugins.gradle.service.project.GradleOperationHelperExtension;
 import org.jetbrains.plugins.gradle.service.project.ProjectResolverContext;
+import org.jetbrains.plugins.gradle.service.task.GradleTaskManager;
 import org.jetbrains.plugins.gradle.settings.DistributionType;
 import org.jetbrains.plugins.gradle.settings.GradleExecutionSettings;
-import org.jetbrains.plugins.gradle.tooling.internal.init.Init;
 import org.jetbrains.plugins.gradle.util.GradleConstants;
 import org.jetbrains.plugins.gradle.util.GradleUtil;

 import java.awt.geom.IllegalPathStateException;
-import java.io.*;
-import java.nio.charset.StandardCharsets;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
 import java.nio.file.Path;
 import java.util.*;
 import java.util.function.Supplier;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;

 import static org.jetbrains.plugins.gradle.GradleConnectorService.withGradleConnection;
-import static org.jetbrains.plugins.gradle.service.execution.LocalGradleExecutionAware.LOCAL_TARGET_TYPE_ID;
-import static org.jetbrains.plugins.gradle.service.task.GradleTaskManager.INIT_SCRIPT_KEY;
-import static org.jetbrains.plugins.gradle.service.task.GradleTaskManager.INIT_SCRIPT_PREFIX_KEY;

 public class GradleExecutionHelper {

@@ -323,7 +317,7 @@ public class GradleExecutionHelper {
    lines.add("}");
    lines.add("");

-    File initScriptFile = writeToFileGradleInitScript(lines.toString(), "wrapper_init");
+    File initScriptFile = GradleInitScriptUtil.createInitScript("wrapper_init", lines.toString());
    settings.withArguments(GradleConstants.INIT_SCRIPT_CMD_OPTION, initScriptFile.getCanonicalPath());

    return () -> FileUtil.loadFileOrNull(fileWithPathToProperties);
@@ -471,10 +465,8 @@ public class GradleExecutionHelper {
    }
    else {
      var testTaskPatterns = extractTestTaskPatterns(arguments);
-      var path = renderTestFilterInitScript(testTaskPatterns, isTestExecForced(settings));
-      if (path != null) {
-        ContainerUtil.addAll(arguments, GradleConstants.INIT_SCRIPT_CMD_OPTION, path);
-      }
+      var path = GradleInitScriptUtil.createTestInitScript(testTaskPatterns, isTestExecForced(settings));
+      ContainerUtil.addAll(arguments, GradleConstants.INIT_SCRIPT_CMD_OPTION, path.getAbsolutePath());
    }
    addIdeaParameters(arguments, settings);
    operation.withArguments(arguments);
@@ -576,7 +568,7 @@ public class GradleExecutionHelper {
      ExternalSystemExecutionAware.Companion.getEnvironmentConfigurationProvider(settings);
    TargetEnvironmentConfiguration environmentConfiguration =
      environmentConfigurationProvider != null ? environmentConfigurationProvider.getEnvironmentConfiguration() : null;
-    if (environmentConfiguration != null && !LOCAL_TARGET_TYPE_ID.equals(environmentConfiguration.getTypeId())) {
+    if (environmentConfiguration != null && !LocalGradleExecutionAware.LOCAL_TARGET_TYPE_ID.equals(environmentConfiguration.getTypeId())) {
      if (settings.isPassParentEnvs()) {
        LOG.warn("Host system environment variables will not be passed for the target run.");
      }
@@ -665,56 +657,21 @@ public class GradleExecutionHelper {
    return i <= 0 ? Couple.of(arg, "") : Couple.of(arg.substring(0, i), arg.substring(i));
  }

-  @Nullable
-  public static File generateInitScript(boolean isBuildSrcProject, @NotNull Set<Class<?>> toolingExtensionClasses) {
-    InputStream stream = Init.class.getResourceAsStream("/org/jetbrains/plugins/gradle/tooling/internal/init/init.gradle");
-    if (stream == null) {
-      LOG.warn("Can't find init script template");
-      return null;
-    }
-    try (Reader reader = new InputStreamReader(stream, StandardCharsets.UTF_8)) {
-      String toolingExtensionsJarPaths = getToolingExtensionsJarPaths(toolingExtensionClasses);
-      String script = StreamUtil.readText(reader).replaceFirst(Pattern.quote("${EXTENSIONS_JARS_PATH}"), Matcher.quoteReplacement(toolingExtensionsJarPaths));
-      if (isBuildSrcProject) {
-        String buildSrcDefaultInitScript = getBuildSrcDefaultInitScript();
-        if (buildSrcDefaultInitScript == null) return null;
-        script += buildSrcDefaultInitScript;
-      }
-
-      return writeToFileGradleInitScript(script, "ijinit");
-    }
-    catch (Exception e) {
-      LOG.warn("Can't generate IJ gradle init script", e);
-      return null;
-    }
-  }
-
-  public static File writeToFileGradleInitScript(@NotNull String content, @NotNull String filePrefix) throws IOException {
-    byte[] contentBytes = content.getBytes(StandardCharsets.UTF_8);
-    int contentLength = contentBytes.length;
-    return FileUtil.findSequentFile(new File(FileUtil.getTempDirectory()), filePrefix, GradleConstants.EXTENSION, file -> {
-      try {
-        if (!file.exists()) {
-          FileUtil.writeToFile(file, contentBytes, false);
-          file.deleteOnExit();
-          return true;
-        }
-        if (contentLength != file.length()) return false;
-        return content.equals(FileUtil.loadFile(file, StandardCharsets.UTF_8));
-      }
-      catch (IOException ignore) {
-        // Skip file with access issues. Will attempt to check the next file
-      }
-      return false;
-    });
+  @ApiStatus.Internal
+  public static void attachTargetPathMapperInitScript(@NotNull GradleExecutionSettings executionSettings) {
+    var initScriptFile = GradleInitScriptUtil.createInitScript("ijmapper", "if (!ext.has('mapPath')) ext.mapPath = { path -> path }\n");
+    executionSettings.prependArguments(GradleConstants.INIT_SCRIPT_CMD_OPTION, initScriptFile.getAbsolutePath());
  }

  @ApiStatus.Experimental
  @NotNull
  public static Map<String, String> getConfigurationInitScripts(@NonNls GradleRunConfiguration configuration) {
-    final String initScript = configuration.getUserData(INIT_SCRIPT_KEY);
+    final String initScript = configuration.getUserData(GradleTaskManager.INIT_SCRIPT_KEY);
    if (StringUtil.isNotEmpty(initScript)) {
-      String prefix = Objects.requireNonNull(configuration.getUserData(INIT_SCRIPT_PREFIX_KEY), "init script file prefix is required");
+      String prefix = configuration.getUserData(GradleTaskManager.INIT_SCRIPT_PREFIX_KEY);
+      if (prefix == null) {
+        throw new NullPointerException("init script file prefix is required");
+      }
      Map<String, String> map = new LinkedHashMap<>();
      map.put(prefix, initScript);
      return map;
@@ -722,34 +679,6 @@ public class GradleExecutionHelper {
    return Collections.emptyMap();
  }

-  @ApiStatus.Internal
-  public static void attachTargetPathMapperInitScript(@NotNull GradleExecutionSettings executionSettings) {
-    try {
-      File initScriptFile = writeToFileGradleInitScript(
-        "if(!ext.has('mapPath')) ext.mapPath = { path -> path }\n", "ijmapper");
-      executionSettings.prependArguments(GradleConstants.INIT_SCRIPT_CMD_OPTION, initScriptFile.getAbsolutePath());
-    }
-    catch (IOException e) {
-      LOG.warn("Can't generate IJ gradle init script", e);
-    }
-  }
-
-  @Nullable
-  public static String getBuildSrcDefaultInitScript() {
-    InputStream stream = Init.class.getResourceAsStream("/org/jetbrains/plugins/gradle/tooling/internal/init/buildSrcInit.gradle");
-    if (stream == null) {
-      LOG.warn("Can't find default init script template");
-      return null;
-    }
-    try (Reader reader = new InputStreamReader(stream, StandardCharsets.UTF_8)) {
-      return StreamUtil.readText(reader);
-    }
-    catch (Exception e) {
-      LOG.warn("Can't use IJ gradle init script", e);
-      return null;
-    }
-  }
-
  @Nullable
  public static GradleVersion getGradleVersion(@NotNull ProjectConnection connection,
                                               @NotNull ExternalSystemTaskId taskId,
@@ -896,57 +825,8 @@ public class GradleExecutionHelper {
    return taskToTestsPatterns;
  }

-  private static String toGroovyList(@NotNull List<String> list) {
-    var rawList = list.stream()
-      .map(it -> toGroovyString(it))
-      .collect(Collectors.joining(","));
-    return "[" + rawList + "]";
-  }
-
-  @NotNull
-  public static String toGroovyString(@NotNull String string) {
-    StringBuilder stringBuilder = new StringBuilder();
-    for (char ch : string.toCharArray()) {
-      if (ch == '\\') {
-        stringBuilder.append("\\\\");
-      }
-      else if (ch == '\'') {
-        stringBuilder.append("\\'");
-      }
-      else if (ch == '$') {
-        stringBuilder.append("\\$");
-      }
-      else {
-        stringBuilder.append(ch);
-      }
-    }
-    return "'" + stringBuilder + "'";
-  }
-
-  @Nullable
-  public static String renderTestFilterInitScript(@NotNull Set<String> testTasksPatterns, boolean forceExecution) {
-    InputStream stream = Init.class.getResourceAsStream("/org/jetbrains/plugins/gradle/tooling/internal/init/testFilterInit.gradle");
-    if (stream == null) {
-      LOG.error("Can't find test filter init script template");
-      return null;
-    }
-    try (Reader reader = new InputStreamReader(stream, StandardCharsets.UTF_8)) {
-      var testNameIncludes = Matcher.quoteReplacement(toGroovyList(new ArrayList<>(testTasksPatterns)));
-      String script = StreamUtil.readText(reader)
-        .replaceFirst(Pattern.quote("${TEST_NAME_INCLUDES}"), testNameIncludes)
-        .replaceFirst(Pattern.quote("${FORCE_TEST_EXECUTION}"), forceExecution ? " task.outputs.upToDateWhen { false } " : "");
-      File tempFile = writeToFileGradleInitScript(script, "ijtestinit");
-      return tempFile.getAbsolutePath();
-    }
-    catch (Exception e) {
-      LOG.warn("Can't generate IJ gradle test filter init script", e);
-      return null;
-    }
-  }
-
-  @NotNull
-  public static String getToolingExtensionsJarPaths(@NotNull Set<Class<?>> toolingExtensionClasses) {
-    final Set<String> jarPaths = ContainerUtil.map2SetNotNull(toolingExtensionClasses, aClass -> {
+  public static @NotNull Set<String> getToolingExtensionsJarPaths(@NotNull Set<Class<?>> toolingExtensionClasses) {
+    return ContainerUtil.map2SetNotNull(toolingExtensionClasses, aClass -> {
      String path = PathManager.getJarPathForClass(aClass);
      if (path != null) {
        if (FileUtilRt.getNameWithoutExtension(path).equals("gradle-api-" + GradleVersion.current().getBaseVersion())) {
@@ -965,17 +845,6 @@ public class GradleExecutionHelper {
      }
      return null;
    });
-    StringBuilder buf = new StringBuilder();
-    buf.append('[');
-    for (Iterator<String> it = jarPaths.iterator(); it.hasNext(); ) {
-      String jarPath = it.next();
-      buf.append("mapPath(\"").append(jarPath).append("\")");
-      if (it.hasNext()) {
-        buf.append(',');
-      }
-    }
-    buf.append(']');
-    return buf.toString();
  }

  @NotNull
@@ -0,0 +1,28 @@
+// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+@file:JvmName("GradleGroovyUtil")
+
+package org.jetbrains.plugins.gradle.service.execution
+
+fun <K, V> Map<K, V>.toGroovyMap(mapKey: K.() -> String, mapValue: V.() -> String): String {
+  if (isEmpty()) {
+    return "[:]"
+  }
+  return "[" + entries.joinToString(",") { it.key.mapKey() + ":" + it.value.mapValue() } + "]"
+}
+
+fun <T> Collection<T>.toGroovyList(map: T.() -> String): String {
+  return "[" + joinToString(",", transform = map) + "]"
+}
+
+fun String.toGroovyString(): String {
+  val stringBuilder = StringBuilder()
+  for (ch in toCharArray()) {
+    when (ch) {
+      '\\' -> stringBuilder.append("\\\\")
+      '\'' -> stringBuilder.append("\\'")
+      '$' -> stringBuilder.append("\\$")
+      else -> stringBuilder.append(ch)
+    }
+  }
+  return "'$stringBuilder'"
+}
@@ -0,0 +1,71 @@
+// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+@file:JvmName("GradleInitScriptUtil")
+
+package org.jetbrains.plugins.gradle.service.execution
+
+import com.intellij.openapi.util.io.FileUtil
+import org.jetbrains.plugins.gradle.tooling.internal.init.Init
+import org.jetbrains.plugins.gradle.util.GradleConstants
+import java.io.File
+import java.io.IOException
+import java.nio.charset.StandardCharsets
+import java.util.regex.Matcher
+
+
+fun createMainInitScript(isBuildSrcProject: Boolean, toolingExtensionClasses: Set<Class<*>>): File {
+  val jarPaths = GradleExecutionHelper.getToolingExtensionsJarPaths(toolingExtensionClasses)
+  return createInitScript("ijInit", loadInitScript("/org/jetbrains/plugins/gradle/tooling/internal/init/Init.gradle", mapOf(
+    "EXTENSIONS_JARS_PATH" to jarPaths.toGroovyList { "mapPath(" + toGroovyString() + ")" },
+    "IS_BUILD_SCR_PROJECT" to isBuildSrcProject.toString()
+  )))
+}
+
+fun createTestInitScript(testPatterns: Set<String>, forceExecution: Boolean): File {
+  return createInitScript("ijTestInit", loadInitScript("/org/jetbrains/plugins/gradle/tooling/internal/init/testFilterInit.gradle", mapOf(
+    "TEST_PATTERNS" to testPatterns.toGradleGroovyList { toGradleGroovyString() },
+    "FORCE_TEST_EXECUTION" to forceExecution.toGradleGroovyBoolean()
+  )))
+}
+
+private fun loadInitScript(resourcePath: String, parameters: Map<String, String>): String {
+  var script = loadInitScript(resourcePath)
+  for ((key, value) in parameters) {
+    val replacement = Matcher.quoteReplacement(value)
+    script = script.replaceFirst(key.toRegex(), replacement)
+  }
+  return script
+}
+
+private fun loadInitScript(resourcePath: String): String {
+  val resource = Init::class.java.getResource(resourcePath)
+  if (resource == null) {
+    throw IllegalArgumentException("Cannot find init file $resourcePath")
+  }
+  try {
+    return resource.readText()
+  }
+  catch (e: IOException) {
+    throw IllegalStateException("Cannot read init file $resourcePath", e)
+  }
+}
+
+fun createInitScript(prefix: String, content: String): File {
+  val contentBytes = content.toByteArray(StandardCharsets.UTF_8)
+  val contentLength = contentBytes.size
+  return FileUtil.findSequentFile(File(FileUtil.getTempDirectory()), prefix, GradleConstants.EXTENSION) { file: File ->
+    try {
+      if (!file.exists()) {
+        FileUtil.writeToFile(file, contentBytes, false)
+        @Suppress("SSBasedInspection")
+        file.deleteOnExit()
+        return@findSequentFile true
+      }
+      if (contentLength.toLong() != file.length()) return@findSequentFile false
+      return@findSequentFile content == FileUtil.loadFile(file, StandardCharsets.UTF_8)
+    }
+    catch (ignore: IOException) {
+      // Skip file with access issues. Will attempt to check the next file
+    }
+    false
+  }
+}
@@ -51,6 +51,7 @@ import org.jetbrains.plugins.gradle.model.data.CompositeBuildData;
 import org.jetbrains.plugins.gradle.model.data.GradleSourceSetData;
 import org.jetbrains.plugins.gradle.remote.impl.GradleLibraryNamesMixer;
 import org.jetbrains.plugins.gradle.service.execution.GradleExecutionHelper;
+import org.jetbrains.plugins.gradle.service.execution.GradleInitScriptUtil;
 import org.jetbrains.plugins.gradle.settings.DistributionType;
 import org.jetbrains.plugins.gradle.settings.GradleBuildParticipant;
 import org.jetbrains.plugins.gradle.settings.GradleExecutionSettings;
@@ -263,10 +264,8 @@ public class GradleProjectResolver implements ExternalSystemProjectResolver<Grad
    }

    GradleExecutionHelper.attachTargetPathMapperInitScript(executionSettings);
-    File initScript = GradleExecutionHelper.generateInitScript(isBuildSrcProject, toolingExtensionClasses);
-    if (initScript != null) {
-      executionSettings.withArguments(GradleConstants.INIT_SCRIPT_CMD_OPTION, initScript.getAbsolutePath());
-    }
+    File initScript = GradleInitScriptUtil.createMainInitScript(isBuildSrcProject, toolingExtensionClasses);
+    executionSettings.withArguments(GradleConstants.INIT_SCRIPT_CMD_OPTION, initScript.getAbsolutePath());

    BuildActionRunner buildActionRunner = new BuildActionRunner(resolverCtx, projectImportAction, executionSettings, myHelper);
    resolverCtx.checkCancelled();
@@ -38,7 +38,10 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.gradle.service.GradleFileModificationTracker;
 import org.jetbrains.plugins.gradle.service.GradleInstallationManager;
-import org.jetbrains.plugins.gradle.service.execution.*;
+import org.jetbrains.plugins.gradle.service.execution.GradleExecutionHelper;
+import org.jetbrains.plugins.gradle.service.execution.GradleGroovyUtil;
+import org.jetbrains.plugins.gradle.service.execution.GradleInitScriptUtil;
+import org.jetbrains.plugins.gradle.service.execution.GradleRunConfiguration;
 import org.jetbrains.plugins.gradle.service.project.GradleProjectResolver;
 import org.jetbrains.plugins.gradle.service.project.GradleProjectResolverExtension;
 import org.jetbrains.plugins.gradle.service.project.GradleProjectResolverUtil;
@@ -49,7 +52,6 @@ import org.jetbrains.plugins.gradle.settings.GradleSettings;
 import org.jetbrains.plugins.gradle.util.GradleConstants;

 import java.io.File;
-import java.io.IOException;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;
@@ -132,7 +134,7 @@ public class GradleTaskManager implements ExternalSystemTaskManager<GradleExecut
      setupGradleScriptDebugging(settings);
      setupDebuggerDispatchPort(settings);

-      var isApplicableTestLauncher = isApplicableTestLauncher(settings);
+      var isApplicableTestLauncher = isApplicableTestLauncher(tasks, settings);
      appendInitScriptArgument(tasks, jvmParametersSetup, settings, gradleVersion, isApplicableTestLauncher);

      for (GradleBuildParticipant buildParticipant : settings.getExecutionWorkspace().getBuildParticipants()) {
@@ -329,21 +331,9 @@ public class GradleTaskManager implements ExternalSystemTaskManager<GradleExecut
  private static void writeAndAppendScript(@NotNull GradleExecutionSettings effectiveSettings,
                                           @NotNull String initScript,
                                           @NotNull String initScriptPrefix) {
-    try {
-      String initScriptPrefixName = FileUtil.sanitizeFileName(initScriptPrefix);
-      File tempFile = GradleExecutionHelper.writeToFileGradleInitScript(initScript, initScriptPrefixName);
-      effectiveSettings.withArguments(GradleConstants.INIT_SCRIPT_CMD_OPTION, tempFile.getAbsolutePath());
-    }
-    catch (IOException e) {
-      throw wrapWithESException(e);
-    }
-  }
-
-  @NotNull
-  private static ExternalSystemException wrapWithESException(IOException e) {
-    ExternalSystemException externalSystemException = new ExternalSystemException(e);
-    externalSystemException.initCause(e);
-    return externalSystemException;
+    String initScriptPrefixName = FileUtil.sanitizeFileName(initScriptPrefix);
+    File tempFile = GradleInitScriptUtil.createInitScript(initScriptPrefixName, initScript);
+    effectiveSettings.withArguments(GradleConstants.INIT_SCRIPT_CMD_OPTION, tempFile.getAbsolutePath());
  }

  public static void setupGradleScriptDebugging(@NotNull GradleExecutionSettings effectiveSettings) {
@@ -425,10 +415,11 @@ public class GradleTaskManager implements ExternalSystemTaskManager<GradleExecut
    tools.add(taskClass);
    tools.add(GsonBuilder.class);
    tools.add(ExternalSystemException.class);
-    String paths = GradleExecutionHelper.getToolingExtensionsJarPaths(tools);
+    Set<String> paths = GradleExecutionHelper.getToolingExtensionsJarPaths(tools);
+    String toolingPaths = GradleGroovyUtil.toGroovyList(paths, it -> "mapPath(" + GradleGroovyUtil.toGroovyString(it) + ")");
    String initScript = "initscript {\n" +
                        "  dependencies {\n" +
-                        "    classpath files(" + paths + ")\n" +
+                        "    classpath files(" + toolingPaths + ")\n" +
                        "  }\n" +
                        "}\n" +
                        "allprojects {\n" +
@@ -65,19 +65,19 @@ public class GradleExecutionHelperTest {
  public void testWriteToFileGradleInitScript() throws IOException {
    String prefix = "init";

-    File tempFile = writeToFileGradleInitScript("foo", prefix);
+    File tempFile = GradleInitScriptUtil.createInitScript(prefix, "foo");
    assertTrue(tempFile.exists());
    assertEquals("foo", loadFile(tempFile));

-    assertTrue(filesEqual(tempFile, writeToFileGradleInitScript("foo", prefix)));
+    assertTrue(filesEqual(tempFile, GradleInitScriptUtil.createInitScript(prefix, "foo")));

-    File anotherTempFile = writeToFileGradleInitScript("bar", prefix);
+    File anotherTempFile = GradleInitScriptUtil.createInitScript(prefix, "bar");
    assertTrue(anotherTempFile.exists());
    assertEquals("bar", loadFile(anotherTempFile));

    assertFalse(filesEqual(tempFile, anotherTempFile));

-    assertTrue(filesEqual(anotherTempFile, writeToFileGradleInitScript("bar", prefix)));
+    assertTrue(filesEqual(anotherTempFile, GradleInitScriptUtil.createInitScript(prefix, "bar")));
  }

  @Test
@@ -10,9 +10,13 @@ import org.jetbrains.plugins.gradle.tooling.internal.ExtraModelBuilder
 import java.util.concurrent.CopyOnWriteArrayList
 import javax.inject.Inject

+//noinspection GrUnresolvedAccess
+boolean isBuildSrcProject = IS_BUILD_SCR_PROJECT
+
 initscript {
  dependencies {
-    classpath files(${EXTENSIONS_JARS_PATH})
+    //noinspection GrUnresolvedAccess
+    classpath files(EXTENSIONS_JARS_PATH)
  }
 }

@@ -114,3 +118,25 @@ class RegistryProcessor implements ProjectEvaluationListener {
  @Override
  void afterEvaluate(Project project, ProjectState state) {  }
 }
+
+if (isBuildSrcProject) {
+  def oldVersion =  GradleVersion.current() < GradleVersion.version("6.0")
+  allprojects { project ->
+    if (project.name == 'buildSrc') {
+      if (oldVersion) {
+        apply plugin: 'groovy'
+        dependencies {
+          compile gradleApi()
+          compile localGroovy()
+        }
+      } else {
+        apply plugin: 'java-library'
+        apply plugin: 'groovy'
+        dependencies {
+          api gradleApi()
+          api localGroovy()
+        }
+      }
+    }
+  }
+}
@@ -1,20 +0,0 @@
-
-def oldVersion =  org.gradle.util.GradleVersion.current() < org.gradle.util.GradleVersion.version("6.0")
-allprojects { project ->
-  if (project.name == 'buildSrc') {
-    if (oldVersion) {
-      apply plugin: 'groovy'
-      dependencies {
-        compile gradleApi()
-        compile localGroovy()
-      }
-    } else {
-      apply plugin: 'java-library'
-      apply plugin: 'groovy'
-      dependencies {
-        api gradleApi()
-        api localGroovy()
-      }
-    }
-  }
-}
@@ -1,6 +1,6 @@
 //file:noinspection GrPackage

-String[] ijTestIncludes = ${TEST_NAME_INCLUDES}
+String[] ijTestIncludes = TEST_PATTERNS

 Class abstractTestTaskClass = null
 try {
@@ -13,7 +13,9 @@ gradle.taskGraph.whenReady { taskGraph ->
  taskGraph.allTasks.each { Task task ->
    if (task instanceof Test || (abstractTestTaskClass != null && abstractTestTaskClass.isAssignableFrom(task.class))) {
      try {
-        ${FORCE_TEST_EXECUTION}
+        if (FORCE_TEST_EXECUTION) {
+          task.outputs.upToDateWhen { false }
+        }
        String[] strings = ['*']
        if(ijTestIncludes.size() > 0 && ijTestIncludes != strings) {
          def filter = task.getFilter()
@@ -32,6 +32,7 @@ import org.jetbrains.plugins.gradle.model.ClassSetImportModelProvider;
 import org.jetbrains.plugins.gradle.model.ClasspathEntryModel;
 import org.jetbrains.plugins.gradle.model.ProjectImportAction;
 import org.jetbrains.plugins.gradle.service.execution.GradleExecutionHelper;
+import org.jetbrains.plugins.gradle.service.execution.GradleInitScriptUtil;
 import org.jetbrains.plugins.gradle.settings.DistributionType;
 import org.jetbrains.plugins.gradle.settings.GradleExecutionSettings;
 import org.jetbrains.plugins.gradle.tooling.VersionMatcherRule;
@@ -153,8 +154,7 @@ public abstract class AbstractModelBuilderTest {
      BuildActionExecuter<ProjectImportAction.AllModels> buildActionExecutor = connection.action(projectImportAction);
      GradleExecutionSettings executionSettings = new GradleExecutionSettings(null, null, DistributionType.BUNDLED, false);
      GradleExecutionHelper.attachTargetPathMapperInitScript(executionSettings);
-      File initScript = GradleExecutionHelper.generateInitScript(false, getToolingExtensionClasses());
-      assertNotNull(initScript);
+      File initScript = GradleInitScriptUtil.createMainInitScript(false, getToolingExtensionClasses());
      executionSettings.withArguments(GradleConstants.INIT_SCRIPT_CMD_OPTION, initScript.getAbsolutePath());

      buildActionExecutor.withArguments(executionSettings.getArguments());
@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.tooling.core.Extras
 import org.jetbrains.plugins.gradle.model.ClassSetImportModelProvider
 import org.jetbrains.plugins.gradle.model.ProjectImportAction
 import org.jetbrains.plugins.gradle.service.execution.GradleExecutionHelper
+import org.jetbrains.plugins.gradle.service.execution.createMainInitScript
 import org.jetbrains.plugins.gradle.settings.DistributionType
 import org.jetbrains.plugins.gradle.settings.GradleExecutionSettings
 import org.jetbrains.plugins.gradle.tooling.builder.AbstractModelBuilderTest
@@ -84,26 +85,24 @@ fun <T : Any> buildGradleModel(

        val executionSettings = GradleExecutionSettings(null, null, DistributionType.BUNDLED, false)
        GradleExecutionHelper.attachTargetPathMapperInitScript(executionSettings)
-        val initScript = GradleExecutionHelper.generateInitScript(
-            false, AbstractModelBuilderTest.getToolingExtensionClasses() +
-                    setOf(
-                        /* Representative of the `gradle-tooling` module */
-                        KotlinMPPGradleModelBuilder::class.java,
+        val toolingExtensionClasses = AbstractModelBuilderTest.getToolingExtensionClasses()
+        val kotlinToolingExtensionClasses = setOf(
+            /* Representative of the `gradle-tooling` module */
+            KotlinMPPGradleModelBuilder::class.java,

-                        /* Representative of the `kotlin.project-module` module */
-                        KotlinCompilation::class.java,
+            /* Representative of the `kotlin.project-module` module */
+            KotlinCompilation::class.java,

-                        /* Representative of the `kotlin-tooling-core` library */
-                        Extras::class.java,
+            /* Representative of the `kotlin-tooling-core` library */
+            Extras::class.java,

-                        /* Representative of the `kotlin-gradle-plugin-idea` library */
-                        IdeaKotlinDependency::class.java,
+            /* Representative of the `kotlin-gradle-plugin-idea` library */
+            IdeaKotlinDependency::class.java,

-                        /* Representative of the kotlin stdlib */
-                        Unit::class.java
-                    )
-
-        ) ?: error("Failed to generateInitScript")
+            /* Representative of the kotlin stdlib */
+            Unit::class.java
+        )
+        val initScript = createMainInitScript(false, toolingExtensionClasses + kotlinToolingExtensionClasses)
        executionSettings.withArguments(GradleConstants.INIT_SCRIPT_CMD_OPTION, initScript.absolutePath)

        val buildActionExecutor = gradleConnection.action(projectImportAction)