Export samefile, make it smarter for nonexistent inputs

[tkelman]

Just realized at #9376 (comment) that anywhere we do file path comparisons is potentially very error-prone on case-insensitive filesystems. We have realpath and normpath which look similar but are implemented differently, and neither appear to be doing anything about case. Should we have a special string literal specifically for file paths that has comparison defined? Or a differently-named function to compare if file paths point to the same thing? normalize_string with casefold=true might be the sane thing to use here, but do we currently have an API for determining whether the file system is case sensitive? On Mac it's configurable so can't always be assumed one way or the other, right?

[nalimilan]

Copying my comment from the other issue. As this seems really tricky, and can vary depending on the filesystem, it looks like it's best to actually try to open files (when checking whether a file already exists) or compare their inodes (when checking for equality), instead of trying to normalize paths:

I guess it could on Windows and OS X. But it looks like it's a rabbit hole: on OS X, you should also decompose the Unicode path. So the most reliable solution is to try to open both files and see whether they point to the same inode, which is what os.path.samefile does in Python. It would certainly be a useful addition to Julia.
See the recent discussion at https://lwn.net/Articles/626898/

[tkelman]

I'm blind. We already have a Base.samefile that compares device and inode from stat, it's just not exported.

julia/base/stat.jl

Line 117 in 98ce78b

samefile(a::String, b::String) = samefile(stat(a),stat(b))

We should just be conscious of when to use it, try to keep it in mind, see if we're doing path comparisons anywhere without realizing this potential gotcha.

[StefanKarpinski]

Sorry, I was vaguely following this and kind of confused. Didn't realized that samefile was not exported – it should be.

[tkelman]

As mentioned here #9376 (comment) samefile should maybe try to do something slightly smarter for file paths that don't exist yet.

[nalimilan]

Indeed. But contrary to what @staticfloat said there, I think path normalization is too brittle, as rules vary even depending on the filesystem the file is on. Python's samefile fails when one of the paths does not point to an existing file. I think that's what Julia should do, as it's the only way to completely guarantee that if you create the files, they won't point to the same inode in the end (thus possibly overwriting one another).

So the only reliable way to find out if two non-existent files are (would be) the same is to create one of them, and remove it afterwards. That may be a bit too many operations happening behind the scenes.

A smarter solution would be to fail only when none of the two files exist. If one of them exists, and stat fails on the other, it means they are not the same, so samefile can return false. Then people would just have to create one of the files before instead of after checking. I guess in most situations one of the files already exists anyway.