import org.gradle.internal.service.scopes.ServiceScope;

import javax.annotation.Nullable;
import java.io.File;

@ServiceScope(Scope.Project.class)
public interface TemporaryFileProvider {
    /**
     * Allocates a new temporary file with the exact specified path,
     * relative to the temporary file directory. Does not create the file.
     * Provides no guarantees around whether the file already exists.
     *

    }

    @Override
    protected String[] getTasksToBuildAndRunUnitTest(String architecture) {
        return super.getTasksToBuildAndRunUnitTest(architecture) + tasks.withArchitecture(architecture).test.relocate
    }

    @Override
    protected String[] getTasksToCompileComponentUnderTest(String architecture) {
        def debugTasks = tasks.withArchitecture(architecture).debug
        return [debugTasks.compile]
    }

    /**
     * Returns {@link Artifact} instance where to relocate to, or {@code null}.
     *
     * @param session The session, never {@code null}.
     * @param result The artifact descriptor result, never {@code null}.
     * @param model The artifact model, never {@code null}.
     * @return The {@link Artifact} to relocate to, or {@code null} if no relocation wanted.
     */

	}
	appendWalkStmt(init, ir.NewAssignStmt(base.Pos, tmp, val))
	return typecheck.Expr(typecheck.NodAddr(tmp)).(*ir.AddrExpr)
}

// stackTempAddr returns the expression &tmp, where tmp is a newly
// allocated temporary variable of the given type. Statements to
// zero-initialize tmp are appended to init.
func stackTempAddr(init *ir.Nodes, typ *types.Type) *ir.AddrExpr {
	n := typecheck.TempAt(base.Pos, ir.CurFunc, typ)

rootProject.name = "artifact-transforms-relocate"...

rootProject.name = 'artifact-transforms-relocate'...

    }

    @Nullable // if no installation can be located
    public static GradleInstallation get() {
        return locate().getInstallation();
    }

    public synchronized static CurrentGradleInstallation locate() {
        if (instance == null) {
            instance = CurrentGradleInstallationLocator.locate();
        }
        return instance;
    }

     * have their type information available.
     *
     * As type is part of attribute equality, this method will in many cases <strong>NOT</strong> be useful to
     * locate these attributes within an {@link org.gradle.api.attributes.AttributeContainer} that was created
     * using the strong type information present on attribute constants such as {@link org.gradle.api.attributes.Category#CATEGORY_ATTRIBUTE}.

            return toolSearchPath.locate(compilerType, "swiftc");
        }
        if (compilerType == ToolType.STATIC_LIB_ARCHIVER) {
            return toolSearchPath.locate(compilerType, "ar");
        }
        if (compilerType == ToolType.SYMBOL_EXTRACTOR) {
            return toolSearchPath.locate(compilerType, SymbolExtractorOsConfig.current().getExecutableName());
        }

    }

    /**
     * Locate the grammar file metadata by grammar file path.
     *
     * @param path The grammar file path.
     * @return The grammar file metadata.  May be null if none found.
     */
    public GrammarFileMetadata getGrammarFileByPath(String path) {
        return filesByPath.get(path);
    }

    /**