```
someTask {
    inputFile.from(jar.archivePath)
}
```

The `jar.archivePath` property is of type `File`, which doesn't carry any task dependency.
It means that if you call `someTask` _after_ `jar` has been called, the task will succeed, but if the jar is removed, for example, the task would fail.

            abstract class SomeTask extends DefaultTask {
                @Internal
                abstract MapProperty<String, Long> getProp()

                @TaskAction
                def go() {
                    prop.set((Map<String, Long>)null)
                    prop.get()
                }
            }

            tasks.register('thing', SomeTask)
        """

        when:

        createDirs("a", "b", "c")
        settingsFile << "include 'a', 'b', 'c'"
        file("a/build.gradle") << """
task one(type: SomeTask)
task two(type: SomeTask)

class SomeTask extends DefaultTask {
    @org.gradle.api.tasks.options.Option(description="some value")
    @Input
    String value
}
"""

        when:

        buildFile '''
            class SomeTask extends DefaultTask {
            }
            class SomeExtension {
            }

            SomeTask.metaClass.p1 = 12
            SomeTask.metaClass.m1 = { -> "m1" }
            SomeExtension.metaClass.p2 = 10
            SomeExtension.metaClass.m2 = { String p -> p }

            task t(type: SomeTask)
            extensions.add("e", SomeExtension)

            }
            'settings.gradle'(this.settingsWithBuildScriptsUseProjectName('module1', 'module2'))
        }

        when:
        fails 'module1:someTask'

        then:
        def scripts = scriptDetails()
        scripts.size() == 3
        eachScriptIsUnique(scripts)

    }

    def "task @Input property is implicitly finalized when task starts execution"() {
        given:
        buildFile """
            class SomeTask extends DefaultTask {
                @Input
                final Property<String> prop = project.objects.property(String)

                @OutputFile

If project A has a compile dependency on project B, then building A causes the configuration of both projects.
* The task dependencies declared via the task path are supported and cause relevant projects to be configured. +
Example: `someTask.dependsOn(":some-other-project:someOtherTask")`
* A task requested via task path from the command line (or tooling API) causes the relevant project to be configured. +

        results.testClass('PersonTest').assertTestsExecuted('ok')
    }

    @Test
    void projectPathsResolvedRelativeToRoot() {
        file('relative/a/build.gradle') << """
            task someTask
        """
        file('settings.gradle') << '''
        include ':a'
        project(':a').projectDir = new File('relative/a')
        '''

----
❯ gradle --configuration-cache --configuration-cache-problems=warn someTask -DsomeDestination=dest
include::{snippetsPath}/configurationCache/problemsGroovy/tests/store.out[]
Configuration cache entry stored with 1 problem.
❯ gradle --configuration-cache --configuration-cache-problems=warn someTask -DsomeDestination=dest
include::{snippetsPath}/configurationCache/problemsGroovy/tests/load.out[]

        when:
        render unexpectedInputType {
            type('SomeTask').property('tada')
                .kind("file")
                .missing(location)
                .includeLink()
        }

        then:
        outputEquals """
Type 'SomeTask' property 'tada' file '${location}' is not a file.

Reason: Expected an input to be a file but it was a directory.