Fix Unix FileStatus flag retrieval without perf regression

src/libraries/System.IO.FileSystem/src/System/IO/Enumeration/FileSystemEntry.Unix.cs

@@ -36,8 +36,10 @@ namespace System.IO.Enumeration
 
             // IMPORTANT: Attribute logic must match the logic in FileStatus
 
+            entry._status = default;
+            entry._status.Invalidate();
+
             bool isDirectory = false;
-            bool isSymlink = false;
             if (directoryEntry.InodeType == Interop.Sys.NodeType.DT_DIR)
             {
                 // We know it's a directory.
@@ -46,38 +48,49 @@ namespace System.IO.Enumeration
             // Some operating systems don't have the inode type in the dirent structure,
             // so we use DT_UNKNOWN as a sentinel value. As such, check if the dirent is a
             // directory.
-            else if ((directoryEntry.InodeType == Interop.Sys.NodeType.DT_LNK
-                || directoryEntry.InodeType == Interop.Sys.NodeType.DT_UNKNOWN)
-                && Interop.Sys.Stat(entry.FullPath, out Interop.Sys.FileStatus targetStatus) >= 0)
+            else if ((directoryEntry.InodeType == Interop.Sys.NodeType.DT_LNK || directoryEntry.InodeType == Interop.Sys.NodeType.DT_UNKNOWN) &&
+                     entry._status.TryRefreshSecondaryCache(entry.FullPath)) // Only call stat if inode is link or unknown
             {
-                // Symlink or unknown: Stat to it to see if we can resolve it to a directory.
-                isDirectory = (targetStatus.Mode & Interop.Sys.FileTypes.S_IFMT) == Interop.Sys.FileTypes.S_IFDIR;
+                // Symlink or unknown: Stat should tell us if we can resolve it to a directory.
+                isDirectory = entry._status.HasSecondaryDirectoryFlag;
             }
-            // Same idea as the directory check, just repeated for (and tweaked due to the
-            // nature of) symlinks.
+
+            // Same idea as the directory check, just repeated for (and tweaked due to the nature of) symlinks.
+            bool isSymlink = false;
             if (directoryEntry.InodeType == Interop.Sys.NodeType.DT_LNK)
             {
                 isSymlink = true;
             }
-            else if ((directoryEntry.InodeType == Interop.Sys.NodeType.DT_UNKNOWN)
-                && (Interop.Sys.LStat(entry.FullPath, out Interop.Sys.FileStatus linkTargetStatus) >= 0))
+            else if (directoryEntry.InodeType == Interop.Sys.NodeType.DT_UNKNOWN &&
+                     entry._status.TryRefreshMainCache(entry.FullPath)) // Only call lstat if inode is unknown
             {
-                isSymlink = (linkTargetStatus.Mode & Interop.Sys.FileTypes.S_IFMT) == Interop.Sys.FileTypes.S_IFLNK;
+                isSymlink = entry._status.HasSymbolicLinkFlag;
             }
 
-            entry._status = default;
-            FileStatus.Initialize(ref entry._status, isDirectory);
+            entry._status.InitiallyDirectory = isDirectory;
 
             FileAttributes attributes = default;
             if (isSymlink)
+            {
                 attributes |= FileAttributes.ReparsePoint;
+            }
             if (isDirectory)
+            {
                 attributes |= FileAttributes.Directory;
-            if (directoryEntry.Name[0] == '.')
+            }
+
+            // If at this point we have not collected the main cache (lstat) we don't have a hard requirement
+            // to hit the disk yet, so a soft check is enough to prevent perf regression.
+            // FileSystemEnumerator.MoveNext may hit the disk, if needed, when updating the attributes.
+            if (entry.HasHiddenPrefix || (entry._status.IsMainCacheValid && entry._status.HasHiddenFlag))
+            {
                 attributes |= FileAttributes.Hidden;
+            }
 
             if (attributes == default)
+            {
                 attributes = FileAttributes.Normal;
+            }
 
             entry._initialAttributes = attributes;
             return attributes;
@@ -99,6 +112,8 @@ private ReadOnlySpan<char> FullPath
             }
         }
 
+        private bool HasHiddenPrefix => (_directoryEntry.NameLength > 0 && _directoryEntry.Name[0] == '.');
+
         public ReadOnlySpan<char> FileName
         {
             get
@@ -143,12 +158,22 @@ public FileAttributes Attributes
         public DateTimeOffset LastAccessTimeUtc => _status.GetLastAccessTime(FullPath, continueOnError: true);
         public DateTimeOffset LastWriteTimeUtc => _status.GetLastWriteTime(FullPath, continueOnError: true);
         public bool IsDirectory => _status.InitiallyDirectory;
-        public bool IsHidden => _directoryEntry.Name[0] == '.';
+        public bool IsHidden =>
+            HasHiddenPrefix || _status.IsHidden(FullPath, continueOnError: true); // Need to hit the disk (lstat) to check for flag
 
         public FileSystemInfo ToFileSystemInfo()
         {
+            Debug.Assert(!PathInternal.IsPartiallyQualified(FullPath), "FullPath should be fully qualified when constructed from directory enumeration");
+
             string fullPath = ToFullPath();
-            return FileSystemInfo.Create(fullPath, new string(FileName), ref _status);
+            string fileName = new(FileName);
+
+            FileSystemInfo info = IsDirectory
+                ? new DirectoryInfo(fullPath, fileName: fileName, isNormalized: true)
+                : new FileInfo(fullPath, fileName: fileName, isNormalized: true);
+
+            info.Init(ref _status);
+            return info;
         }
 
         /// <summary>