details == 'If you don\'t declare the normalization, outputs can\'t be re-used between machines or locations on the same machine, therefore caching efficiency drops significantly'
            solutions == [ 'Declare the normalization strategy by annotating the property with either @PathSensitive, @Classpath or @CompileClasspath' ]

            }
        }
    }

    /**
     * Clamp the value to an int, or return {@link Diagnostic#NOPOS} if the value is too large.
     * <p>
     * This is used to ensure that we don't report invalid locations.
     *
     * @param value the value to clamp
     * @return either the clamped value, or {@link Diagnostic#NOPOS}
     */
    private static int clampLocation(long value) {

        return new DefaultFileSystemAccess(
            fileHasher(),
            new StringInterner(),
            fileSystem()::stat,
            virtualFileSystem,
            locations -> {},
            new DirectorySnapshotterStatistics.Collector()
        );
    }

    public static FileCollectionFactory fileCollectionFactory() {

Ensure that the producing and consuming tasks are configured with the same location and attach task dependencies between the tasks.
This can be cumbersome and brittle if any of these values are configurable by a user or configured by multiple plugins, as task properties need to be configured in the correct order and locations, and task dependencies kept in sync as values change.

If an option is configured in multiple locations, the _first one_ found in any of these locations wins:

[cols="~,~,~,~"]
|===
|Priority |Method |Location |Details

|1
|Command line interface
|.
|In the command line using `-D`.

|2
|`gradle.properties` file
|`GRADLE_USER_HOME`

// names except output tensors.
Location OpLoc(const OperatorT& op,
               const std::vector<std::unique_ptr<tflite::TensorT>>& tensors,
               Builder builder, Location base) {
  if (op.outputs.empty()) return base;

  llvm::SmallVector<Location, 4> locations;
  locations.reserve(op.outputs.size());
  for (auto tensor_index : op.outputs) {

		p, src, err = fetch(source, duration, timeout, ui, tr)
		if err != nil {
			return
		}
	}

	if err = p.CheckValid(); err != nil {
		return
	}

	// Update the binary locations from command line and paths.
	locateBinaries(p, s, obj, ui)

	// Collect the source URL for all mappings.
	if src != "" {
		msrc = collectMappingSources(p, src)
		remote = true

|===
|Property Type |Note

|`Property<T>`
|Where `T` is typically `Double`, `Integer`, `Long`, `String`, or `Bool`

|`RegularFileProperty`
|Configurable regular file location, whose value is mutable

|`DirectoryProperty`
|Configurable directory location, whose value is mutable

|`ListProperty<T>`
|List of elements of type `T`

|`SetProperty<T>`
|Set of elements of type `T`

|`MapProperty<K, V>`

    }

    private static List<Location> toLocations(List<InternalLocation> locations) {
        List<Location> result = new ArrayList<>(locations.size());
        for (InternalLocation location : locations) {
            if (location instanceof InternalLineInFileLocation) {
                InternalLineInFileLocation l = (InternalLineInFileLocation) location;

        # IBM's JDK on AIX uses strange locations for the executables
        JAVACMD=\$JAVA_HOME/jre/sh/java
    else
        JAVACMD=\$JAVA_HOME/bin/java
    fi
    if [ ! -x "\$JAVACMD" ] ; then
        die "ERROR: JAVA_HOME is set to an invalid directory: \$JAVA_HOME

Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
    fi
else
    JAVACMD=java