location,
            Function.identity(),
            () -> snapshot(location, SnapshottingFilter.EMPTY)
        );
    }

    @Override
    public Optional<HashCode> readRegularFileContentHash(String location) {
        return virtualFileSystem.findMetadata(location)
            .<Optional<FileSystemLocationSnapshot>>flatMap(snapshot -> {
                if (snapshot.getType() != FileType.RegularFile) {

        /**
         * @return true if this source file requires recompilation, false otherwise.
         */
        private boolean visitSourceFile(File sourceFile) {
            return fileSystemAccess.readRegularFileContentHash(sourceFile.getAbsolutePath())
                .map(fileContent -> {
                    SourceFileState previousState = previous.getState(sourceFile);

                    if (previousState != null) {

                }
            }
        }
    }

    private HashCode getContentHash(File file) {
        fileSystemAccess.invalidate([file.absolutePath])
        return fileSystemAccess.readRegularFileContentHash(file.getAbsolutePath())
            .orElse(new MissingFileSnapshot(file.getAbsolutePath(), file.getName(), AccessType.DIRECT).hash)
    }

            return contents.computeIfAbsent(includePath,
                key -> {
                    File candidate = normalizeIncludePath(searchDir, includePath);
                    return fileSystemAccess.readRegularFileContentHash(candidate.getAbsolutePath())
                        .map(contentHash -> (CachedIncludeFile) new SystemIncludeFile(candidate, key, contentHash))
                        .orElse(MISSING_INCLUDE_FILE);
                });