`<filesystem>`: `std::filesystem::exists` returns false for path longer than 260 symbols

[PolarGoose]

Describe the bug

std::filesystem::exists returns false for an existing path longer than 260 characters and doesn't return an error (the error code is 0).

Command-line test case

C:\Temp>type repro.cpp
#include <cstdlib>
#include <filesystem>
#include <iostream>
#include <string>
#include <system_error>
#include <format>
#include <cassert>

int main()
{
    // File name longer than 260 characters
    const std::filesystem::path filePath = LR"(Reproduction_scenario_uniquie_folder\dddddddddddddddddddddddddddddd\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.txt)";

    std::wcout << std::format(L"filePath length: {}\n", filePath.wstring().size()); // 262

    // Create the folder path recursively if it is not already there.
    const auto mkdirResult = std::system(std::format("cmd.exe /c if not exist \"{}\" mkdir \"{}\"", filePath.parent_path().string(), filePath.parent_path().string()).c_str());
    assert(mkdirResult == 0);

    // Create the file
    const auto echoResult = std::system(std::format("cmd.exe /c echo AAAA> \"{}\"", filePath.string()).c_str());
    assert(echoResult == 0);

    // Check if the file exists
    std::error_code errorCode;
    bool exists = std::filesystem::exists(filePath, errorCode);

    std::cout << std::format("exists: {}\n", exists);
    std::cout << std::format("errorCode value: {}\n", errorCode.value());
    std::cout << std::format("errorCode category: {}\n", errorCode.category().name());
    std::cout << std::format("errorCode message: {}\n", errorCode.message());

    return 1;
}

C:\Temp>cl /EHsc /W4 /std:c++latest .\repro.cpp
Microsoft (R) C/C++ Optimizing Compiler Version 19.51.36248 for x64
Copyright (C) Microsoft Corporation.  All rights reserved.

/std:c++latest is provided as a preview of language features from the latest C++
working draft, and we're eager to hear about bugs and suggestions for improvements.
However, note that these features are provided as-is without support, and subject
to changes or removal as the working draft evolves. See
https://go.microsoft.com/fwlink/?linkid=2045807 for details.

repro.cpp
Microsoft (R) Incremental Linker Version 14.51.36248.0
Copyright (C) Microsoft Corporation.  All rights reserved.

/out:repro.exe
repro.obj

C:\Temp>.\repro.exe
filePath length: 262
exists: false
errorCode value: 0
errorCode category: system
errorCode message: The operation completed successfully.

Expected behavior

std::filesystem::exists should return true if the file with a path longer than 260 characters exists.

[PolarGoose]

I have found that I needed to make my code "long-path aware" by embedding the manifest:
cl.exe /std:c++latest /EHsc /W4 $root/main.cpp /link /MANIFEST:EMBED /MANIFESTINPUT:$root/long_path_aware.manifest.xml
content of long_path_aware.manifest.xml:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
  <application xmlns="urn:schemas-microsoft-com:asm.v3">
    <windowsSettings xmlns:ws2="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
      <ws2:longPathAware>true</ws2:longPathAware>
    </windowsSettings>
  </application>
</assembly>

After that, the code works.

However, the problem still stands:
std::filesystem::exists should return an error like invalid file name or file name is too long. It shouldn't silently swallow the error.

[StephanTLavavej]

We'll need to figure out whether we can distinguish this scenario from the other error codes we inspect.

[PolarGoose]

I think it is possible. I did a brief investigation, and the WinAPI methods return something like "path is too long". Please check yourself, because I might be wrong.

The biggest problem here, in my opinion, is that it might be a breaking change because std::filesystem::exists(very_long_path) should now throw a path is too long exception instead of returning false.