NOTE: Currently, the _daemon JVM discovery_ does not support auto-provisioning of new JVM installations.
This will be added in a future release.

[[sec:tools_and_ides]]
== Tools & IDEs

The <<third_party_integration.adoc#embedding,Gradle Tooling API>> used by IDEs and other tools to integrate with Gradle _always_ uses the Gradle Daemon to execute builds.
If you execute Gradle builds from within your IDE, you already use the Gradle Daemon.

:gradle-issues: https://github.com/gradle/gradle/issues/

This section will walk you through converting your Groovy-based Gradle build scripts to Kotlin.

Gradle's newer Kotlin DSL provides a pleasant editing experience in supported IDEs: content-assist, refactoring, documentation, and more.

image::intellij-idea-android-studio.png[IntelliJ IDEA and Android Studio]

[TIP]
====

Developers can make changes to task inputs or outputs while the task is executing.
They can do this unintentionally and without noticing, for example by making changes in their IDEs while a build is running.
Currently, Gradle has no good way to defend against these changes, and will simply cache whatever is in the output directory once the task is finished.

```java
public Image getImage(URL url, String name) {}
```

## 1.5 A note on IDEs

### 1.5.1 IntelliJ IDEA

IntelliJ IDEA will display `<p>` or an empty `*` as a new line:

```java
/**
 * A
 *
 * B
 ```

```java
/**
 * A
 * <p>
 * B
 ```

You can learn what the task outcomes mean from <<more_about_tasks.adoc#sec:task_outcomes,this listing>>.

[[sec:troubleshooting_ide_integration]]
== Debugging IDE integration

Many infrequent errors within IDEs can be solved by "refreshing" Gradle.
See also more documentation on working with Gradle link:https://www.jetbrains.com/help/idea/gradle.html[in IntelliJ IDEA] and link:http://www.vogella.com/tutorials/EclipseGradle/article.html[in Eclipse].

		// Note: cmd/go/internal/load also errors about TestXXX and BenchmarkXXX functions with type parameters.
		// We have currently decided to also warn before compilation/package loading. This can help users in IDEs.
		at := tokenRange{tparams.Opening, tparams.Closing}
		pass.ReportRangef(at, "%s has type parameters: it will not be run by go test as a %sXXX function", fn.Name.Name, prefix)
	}

Tooling models are used to provide rich IDE integration for Gradle projects, allowing IDEs to understand and work with the project's structure, dependencies, and other aspects.

The system property approach can be used when it is desirable to enable debugging support without making an adhoc change to the runner configuration. Most IDEs offer the capability to set JVM system properties for test execution, and such a feature can be used to set this system property.

[[sub:test-kit-build-cache]]
== Testing with the Build Cache

                                    e.getModelId(), e.getMessage(), pomFile != null ? pomFile.toFile() : null, e);
                        }
                        // validation error, continue project building and delay failing to help IDEs
                        error = e;
                    }

                    modelProblems = result.getProblems();

                    initProject(project, Collections.emptyMap(), result);

By implementing a common interface, checkers from a variety of sources
can be easily selected, incorporated, and reused in a wide range of
driver programs including command-line tools (such as vet), text editors and
IDEs, build and test systems (such as go build, Bazel, or Buck), test
frameworks, code review tools, code-base indexers (such as SourceGraph),
documentation viewers (such as godoc), batch pipelines for large code
bases, and so on.