Add internal AppExecLink support to link APIs

src/libraries/Common/src/Interop/Windows/Interop.Errors.cs

@@ -91,6 +91,7 @@ internal static partial class Errors
         internal const int ERROR_EVENTLOG_FILE_CHANGED = 0x5DF;
         internal const int ERROR_TRUSTED_RELATIONSHIP_FAILURE = 0x6FD;
         internal const int ERROR_RESOURCE_LANG_NOT_FOUND = 0x717;
+        internal const int ERROR_CANT_ACCESS_FILE = 0x780;
         internal const int ERROR_NOT_A_REPARSE_POINT = 0x1126;
     }
 }

src/libraries/Common/src/Interop/Windows/Kernel32/Interop.FileOperations.cs

@@ -10,6 +10,7 @@ internal static partial class IOReparseOptions
             internal const uint IO_REPARSE_TAG_FILE_PLACEHOLDER = 0x80000015;
             internal const uint IO_REPARSE_TAG_MOUNT_POINT = 0xA0000003;
             internal const uint IO_REPARSE_TAG_SYMLINK = 0xA000000C;
+            internal const uint IO_REPARSE_TAG_APPEXECLINK = 0x8000001B;
         }
 
         internal static partial class FileOperations

src/libraries/Common/src/Interop/Windows/Kernel32/Interop.REPARSE_DATA_BUFFER.cs

@@ -38,5 +38,14 @@ internal struct MountPointReparseBuffer
             public ushort PrintNameOffset;
             public ushort PrintNameLength;
         }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct AppExecLinkReparseBuffer
+        {
+            public uint ReparseTag;
+            public ushort ReparseDataLength;
+            public ushort Reserved;
+            public uint StringCount;
+        }
     }
 }

src/libraries/Common/tests/TestUtilities/System/PlatformDetection.cs

@@ -11,6 +11,8 @@
 using System.Runtime.CompilerServices;
 using Microsoft.Win32;
 using Xunit;
+using System.IO.Enumeration;
+using System.Linq;
 
 namespace System
 {
@@ -289,6 +291,44 @@ public static bool IsSubstAvailable
             }
         }
 
+        /// <summary>
+        /// Returns true if the current Windows machine has an Application Execution Alias directory
+        /// located in %LOCALAPPDATA%\Microsoft\WindowsApps, with at least one *.exe file inside.
+        /// </summary>
+        public static bool HasUsableAppExecLinksDirectory
+        {
+            get
+            {
+                try
+                {
+                    if (OperatingSystem.IsWindows())
+                    {
+                        string localAppData = Environment.GetEnvironmentVariable("LOCALAPPDATA");
+                        if (string.IsNullOrWhiteSpace(localAppData))
+                        {
+                            return false;
+                        }
+                        string windowsAppsDir = Path.Join(localAppData, "Microsoft", "WindowsApps");
+                        if (Directory.Exists(windowsAppsDir))
+                        {
+                            // return Directory.GetFiles(windowsAppsDir, "*.exe", new EnumerationOptions() { RecurseSubdirectories = true, MaxRecursionDepth = 3 }).Length > 0;
+                            return new FileSystemEnumerable<string?>(
+                                   windowsAppsDir,
+                                   (ref FileSystemEntry entry) => null,
+                                   new EnumerationOptions { RecurseSubdirectories = true })
+                            {
+                                ShouldIncludePredicate = (ref FileSystemEntry entry) =>
+                                    FileSystemName.MatchesWin32Expression("*.exe", entry.FileName) &&
+                                    entry.Attributes.HasFlag(FileAttributes.ReparsePoint)
+                            }.Any();
+                        }
+                    }
+                }
+                catch { }
+                return false;
+            }
+        }
+
         private static Version GetICUVersion()
         {
             int version = 0;

src/libraries/System.IO.FileSystem/tests/AppExecLinks.Windows.cs

@@ -0,0 +1,57 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.IO.Enumeration;
+using System.Linq;
+using Xunit;
+
+namespace System.IO.Tests
+{
+    [PlatformSpecific(TestPlatforms.Windows)]
+    public class AppExecLinks : BaseSymbolicLinks
+    {
+        [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.HasUsableAppExecLinksDirectory))]
+        [InlineData(false)]
+        [InlineData(true)]
+        public void ResolveAppExecLinkTargets(bool returnFinalTarget)
+        {
+            string windowsAppsDir = Path.Join(Environment.GetEnvironmentVariable("LOCALAPPDATA"), "Microsoft", "WindowsApps");
+            var appExecLinkPaths = new FileSystemEnumerable<string?>(
+                                   windowsAppsDir,
+                                   (ref FileSystemEntry entry) => entry.ToFullPath(),
+                                   new EnumerationOptions { RecurseSubdirectories = true })
+            {
+                ShouldIncludePredicate = (ref FileSystemEntry entry) =>
+                    FileSystemName.MatchesWin32Expression("*.exe", entry.FileName) &&
+                    entry.Attributes.HasFlag(FileAttributes.ReparsePoint)
+            };
+
+            foreach (string appExecLinkPath in appExecLinkPaths)
+            {
+                FileInfo linkInfo = new(appExecLinkPath);
+                Assert.Equal(0, linkInfo.Length);
+                Assert.True(linkInfo.Attributes.HasFlag(FileAttributes.ReparsePoint));
+
+                string? linkTarget = linkInfo.LinkTarget;
+                Assert.NotNull(linkTarget);
+                Assert.NotEqual(appExecLinkPath, linkTarget);
+
+                FileSystemInfo? targetInfoFromFileInfo = linkInfo.ResolveLinkTarget(returnFinalTarget);
+                VerifyFileInfo(targetInfoFromFileInfo);
+
+                FileSystemInfo? targetInfoFromFile = File.ResolveLinkTarget(appExecLinkPath, returnFinalTarget);
+                VerifyFileInfo(targetInfoFromFile);
+            }
+
+            void VerifyFileInfo(FileSystemInfo? info)
+            {
+                Assert.True(info is FileInfo);
+                if (info.Exists) // The target may not exist, that's ok
+                {
+                    Assert.True(((FileInfo)info).Length > 0);
+                    Assert.False(info.Attributes.HasFlag(FileAttributes.ReparsePoint));
+                }
+            }
+        }
+    }
+}

src/libraries/System.IO.FileSystem/tests/System.IO.FileSystem.Tests.csproj

@@ -81,6 +81,7 @@
     <Compile Include="FileStream\ctor_options_as.Windows.cs" />
     <Compile Include="FileStream\FileStreamConformanceTests.Windows.cs" />
     <Compile Include="Junctions.Windows.cs" />
+    <Compile Include="AppExecLinks.Windows.cs" />
     <Compile Include="RandomAccess\Mixed.Windows.cs" />
     <Compile Include="RandomAccess\NoBuffering.Windows.cs" />
     <Compile Include="RandomAccess\SectorAlignedMemory.Windows.cs" />

src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.Windows.cs

@@ -539,13 +539,59 @@ internal static void CreateSymbolicLink(string path, string pathToTarget, bool i
                     Debug.Assert(!PathInternal.IsPartiallyQualified(targetPath));
                     return targetPath.ToString();
                 }
+                else if (rbSymlink.ReparseTag == Interop.Kernel32.IOReparseOptions.IO_REPARSE_TAG_APPEXECLINK)
+                {
+                    success = MemoryMarshal.TryRead(bufferSpan, out Interop.Kernel32.AppExecLinkReparseBuffer rbAppExecLink);
+                    Debug.Assert(success);
+
+                    // The target file is at index 2
+                    if (rbAppExecLink.StringCount >= 3)
+                    {
+                        int stringListOffset = sizeof(Interop.Kernel32.AppExecLinkReparseBuffer);
+                        Span<char> stringList = MemoryMarshal.Cast<byte, char>(bufferSpan.Slice(stringListOffset));
+
+                        return GetAppExecLinkTarget(stringList);
+                    }
+                }
 
                 return null;
             }
             finally
             {
                 ArrayPool<byte>.Shared.Return(buffer);
             }
+
+            // Given an appexeclink reparse point string list, finds the
+            // start and end (null chars) of the 3rd string in the list.
+            static string? GetAppExecLinkTarget(ReadOnlySpan<char> stringList)
+            {
+                // Find the 2nd and 3rd null char
+                int start = -1;
+                int end = -1;
+                int count = 0;
+                for (int i = 0; i < stringList.Length; i++)
+                {
+                    if (stringList[i] == '\0')
+                    {
+                        count++;
+                        if (count == 2)
+                        {
+                            start = i + 1; // exclude null char
+                        }
+                        else if (count == 3)
+                        {
+                            end = i;
+                            break;
+                        }
+                    }
+                }
+                if (start != -1 && end != -1)
+                {
+                    return stringList.Slice(start, end - start).ToString();
+                }
+
+                return null;
+            }
         }
 
         private static unsafe string? GetFinalLinkTarget(string linkPath, bool isDirectory)
@@ -555,9 +601,10 @@ internal static void CreateSymbolicLink(string path, string pathToTarget, bool i
 
             // The file or directory is not a reparse point.
             if ((data.dwFileAttributes & (uint)FileAttributes.ReparsePoint) == 0 ||
-                // Only symbolic links and mount points are supported at the moment.
+                // Only symbolic links, mount points (junctions) and app exec links are supported at the moment.
                 ((data.dwReserved0 & Interop.Kernel32.IOReparseOptions.IO_REPARSE_TAG_SYMLINK) == 0 &&
-                 (data.dwReserved0 & Interop.Kernel32.IOReparseOptions.IO_REPARSE_TAG_MOUNT_POINT) == 0))
+                 (data.dwReserved0 & Interop.Kernel32.IOReparseOptions.IO_REPARSE_TAG_MOUNT_POINT) == 0 &&
+                 (data.dwReserved0 & Interop.Kernel32.IOReparseOptions.IO_REPARSE_TAG_APPEXECLINK) == 0))
             {
                 return null;
             }
@@ -572,7 +619,7 @@ internal static void CreateSymbolicLink(string path, string pathToTarget, bool i
                 // If the handle fails because it is unreachable, is because the link was broken.
                 // We need to fallback to manually traverse the links and return the target of the last resolved link.
                 int error = Marshal.GetLastWin32Error();
-                if (IsPathUnreachableError(error))
+                if (IsPathUnreachableError(error) || error == Interop.Errors.ERROR_CANT_ACCESS_FILE /* Possibly broken AppExecLink */)
                 {
                     return GetFinalLinkTargetSlow(linkPath);
                 }