.read(XmlReaderRequest.builder()
                                .inputStream(is)
                                .location(toolchainsSource.getLocation())
                                .strict(false)
                                .build());
                Location loc = e.getCause() instanceof XMLStreamException xe ? xe.getLocation() : null;
                problems.add(new DefaultBuilderProblem(

     */
    File getExecutable(String name) throws JavaHomeException;

    /**
     * The location of java.
     *
     * @return the java home location
     */
    File getJavaHome();

    /**
     * Returns the tools jar. May return null, for example when Jvm was created via
     * with custom jre location or if jdk is not installed.
     */
    @Nullable
    File getToolsJar();

            writer.print(problem.getSeverity());
            writer.print("] ");
            writer.print(problem.getMessage());
            String location = problem.getLocation();
            if (!location.isEmpty()) {
                writer.print(" @ ");
                writer.println(location);
            }
        }

        return buffer.toString();
    }

            withProblem("$location: external process started")
        }

        where:
        snippetsFactory                      | location
        exec("getProject()").java            | "Unknown location" // TODO(mlopatkin): Fix location there
        javaexec("getProject()").java        | "Unknown location"
        exec("getExecOperations()").java     | "Unknown location"

@EventScope(Scope.BuildTree::class)
interface ProblemFactory {
    /**
     * Returns a default location inferred from the calling thread's state.
     */
    fun locationForCaller(consumer: String? = null): PropertyTrace

    /**
     * Creates a problem with the given message and exception.
     *
     * Problem has no documentation, and a default location is inferred from the calling thread's state.
     */

            builder.${field.name}(merged);
        #if ( $locationTracking )
            if (target.get${capField}() == null) {
                builder.location("${field.name}", source.getLocation("${field.name}"));
            } else if (merged != tgt) {
                builder.location("${field.name}", new InputLocation(-1, -1));
            }
        #end
        }
      #elseif ( $field.to && $field.multiplicity == "*" )

 * {code metadata.bin} into its permanent immutable location. The move happens atomically, and if
 * successful, the newly created immutable workspace is returned.</li>
 * <li>If the move fails because a directory is already present in the immutable location, we assume
 * that we got into a race condition with another Gradle process, and try to reuse the newly appeared

            summary.problemCount,
            equalTo(3)
        )
    }

    private
    fun buildLogicProblem(location: String, message: String) = PropertyProblem(
        PropertyTrace.BuildLogic(Describables.of(location), 1),
        StructuredMessage.build { text(message) }
    )

    private void assertCanFetchClassPathForSubProjectScriptIn(String location) {

        withDefaultSettingsIn(location).append("""
            include("foo", "bar")
        """)

        def parentJar = withEmptyJar("$location/libs/parent.jar")
        def fooJar = withEmptyJar("$location/libs/foo.jar")
        def barJar = withEmptyJar("$location/libs/bar.jar")

        assertTrue parentJar.isFile()

        then:
        failure.assertOutputContains("Hello")
        problems.assertFailureHasProblems(failure) {
            withProblem("${location.replace('/', File.separator)}: external process started")
        }

        where:
        snippetsFactory             | file                           | location
        exec().groovy               | "build.gradle"                 | "Build file 'build.gradle': line 5"