Use correct comment formatting

• Add a space after //
dotnet · adamsitnik · Jun 13, 2023 · Dec 5, 2022 · Dec 5, 2022 · Dec 5, 2022
commit 049627fa50da55ceb4f1126eb48df693bfc8ecf1
diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.CopyFile.OSX.cs b/src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.CopyFile.OSX.cs
@@ -10,10 +10,10 @@ internal static partial class FileSystem
     {
         public static partial void CopyFile(string sourceFullPath, string destFullPath, bool overwrite)
         {
-            //Attempt to clone the file:
+            // Attempt to clone the file:
 
-            //Simplify the destination path (i.e. unlink all the links except the last one itself,
-            //i.e. for /link1/link2, you could get /folder1/link2).
+            // Simplify the destination path (i.e. unlink all the links except the last one itself,
+            // i.e. for /link1/link2, you could get /folder1/link2).
             string destFullPath_Full = Path.GetFullPath(destFullPath);
             string? destPathFolder = Path.GetDirectoryName(destFullPath_Full);
             string destPath;
@@ -42,49 +42,49 @@ public static partial void CopyFile(string sourceFullPath, string destFullPath,
                 }
             }
 
-            //Get the full path of the source path and verify that we're not copying the source file onto itself
+            // Get the full path of the source path and verify that we're not copying the source file onto itself
             string fullSource = TryGetLinkTarget(sourceFullPath, destPath, overwrite) ?? sourceFullPath;
 
-            //Start the file copy and prepare for finalization
+            // Start the file copy and prepare for finalization
             StartedCopyFileState startedCopyFile = StartCopyFile(fullSource, destPath, overwrite, openDst: false);
 
-            //Attempt counter just in case we somehow loop infinite times e.g. on a
-            //filesystem that doesn't actually delete files but pretends it does.
-            //Declare error variable here since it can be used after some jumping around.
+            // Attempt counter just in case we somehow loop infinite times e.g. on a
+            // filesystem that doesn't actually delete files but pretends it does.
+            // Declare error variable here since it can be used after some jumping around.
             int attempts = 0;
             int error;
 
             try
             {
-                //Don't need to re-read the link on our first attempt
+                // Don't need to re-read the link on our first attempt
                 bool failOnRereadDoesntChange = false;
                 if (overwrite)
                 {
-                    //Ensure file is deleted on first try.
-                    //Get a lock to the dest file for compat reasons, and then delete it.
+                    // Ensure file is deleted on first try.
+                    // Get a lock to the dest file for compat reasons, and then delete it.
                     using SafeFileHandle? dstHandle = OpenCopyFileDstHandle(destPath, true, startedCopyFile, false);
                     File.Delete(destPath);
                 }
                 goto tryAgain;
 
-                //We may want to re-read the link to see if its path has changed
+                // We may want to re-read the link to see if its path has changed
                 tryAgainWithReadLink:
                 if (++attempts >= 5) goto throwError;
                 string fullSource2 = TryGetLinkTarget(sourceFullPath, destPath, overwrite) ?? sourceFullPath;
                 if (fullSource != fullSource2)
                 {
-                    //Path has changed
+                    // Path has changed
                     startedCopyFile.Dispose();
                     startedCopyFile = StartCopyFile(fullSource, destPath, overwrite, openDst: false);
                 }
                 else if (failOnRereadDoesntChange)
                 {
-                    //Path hasn't changed and we want to throw the error we got earlier
+                    // Path hasn't changed and we want to throw the error we got earlier
                     goto throwError;
                 }
                 failOnRereadDoesntChange = false;
 
-                //Attempt to clone the file
+                // Attempt to clone the file
                 tryAgain:
                 unsafe
                 {
@@ -94,15 +94,15 @@ public static partial void CopyFile(string sourceFullPath, string destFullPath,
                     }
                 }
 
-                //Check the error
+                // Check the error
                 error = Marshal.GetLastWin32Error();
                 const int ENOTSUP = 45;
                 const int EEXIST = 17;
                 const int ENOENT = 2;
                 bool directoryExist = false;
                 if ((error == ENOTSUP && FileOrDirectoryExists(destPath)) || error == EEXIST)
                 {
-                    //This means the destination existed, try again with the destination deleted if appropriate
+                    // This means the destination existed, try again with the destination deleted if appropriate
                     error = EEXIST;
                     if (Directory.Exists(destPath))
                     {
@@ -111,55 +111,55 @@ public static partial void CopyFile(string sourceFullPath, string destFullPath,
                     }
                     if (overwrite)
                     {
-                        //Get a lock to the dest file for compat reasons, and then delete it.
+                        // Get a lock to the dest file for compat reasons, and then delete it.
                         using SafeFileHandle? dstHandle = OpenCopyFileDstHandle(destPath, true, startedCopyFile, false);
                         File.Delete(destPath);
                         goto tryAgainWithReadLink;
                     }
                 }
                 else if (error == ENOTSUP)
                 {
-                    //This probably means cloning is not supported, try the standard implementation
+                    // This probably means cloning is not supported, try the standard implementation
                     goto fallback;
                 }
                 else if (error == ENOENT)
                 {
-                    //This can happen if the source is a symlink and it has been changed to a different file, and the first has been deleted or renamed, for example.
-                    //failOnRereadDoesntChange means we want to fail if the link didn't change, indicating the source actually doesn't exist.
+                    // This can happen if the source is a symlink and it has been changed to a different file, and the first has been deleted or renamed, for example.
+                    // failOnRereadDoesntChange means we want to fail if the link didn't change, indicating the source actually doesn't exist.
                     failOnRereadDoesntChange = true;
                     goto tryAgainWithReadLink;
                 }
 
-                //Throw an appropriate error
+                // Throw an appropriate error
                 throwError:
                 if (directoryExist)
                 {
                     throw new IOException(SR.Format(SR.Arg_FileIsDirectory_Name, destFullPath));
                 }
                 throw Interop.GetExceptionForIoErrno(new Interop.ErrorInfo(error));
 
-                //Fallback to the standard unix implementation for when cloning is not supported
+                // Fallback to the standard unix implementation for when cloning is not supported
                 fallback:
 
-                //Open the dst handle
+                // Open the dst handle
                 startedCopyFile.dst = OpenCopyFileDstHandle(destFullPath, overwrite, startedCopyFile, true);
 
-                //Copy the file using the standard unix implementation
+                // Copy the file using the standard unix implementation
                 StandardCopyFile(startedCopyFile);
             }
             finally
             {
                 startedCopyFile.Dispose();
             }
 
-            //Attempts to read the path's link target, or returns null even if the path doesn't exist rather than throwing.
-            //Throws an error if 'path' is at any point equal to 'destPath', since it means we're copying onto itself.
-            //Throws an error if 'path' has too many symbolic link levels.
+            // Attempts to read the path's link target, or returns null even if the path doesn't exist rather than throwing.
+            // Throws an error if 'path' is at any point equal to 'destPath', since it means we're copying onto itself.
+            // Throws an error if 'path' has too many symbolic link levels.
             static string? TryGetLinkTarget(string path, string destPath, bool overwrite)
             {
                 if (path == destPath)
                 {
-                    //Throw an appropriate error
+                    // Throw an appropriate error
                     if (overwrite) throw new IOException(SR.Format(SR.IO_SharingViolation_File, destPath));
                     else throw new IOException(SR.Format(SR.IO_FileExists_Name, destPath));
                 }
@@ -169,24 +169,24 @@ public static partial void CopyFile(string sourceFullPath, string destFullPath,
                     string? newTarget;
                     try
                     {
-                        //Attempt to unlink the current link
+                        // Attempt to unlink the current link
                         newTarget = ResolveLinkTargetString(currentTarget ?? path, false, false);
                     }
                     catch
                     {
-                        //This means path's target doesn't exist, stop unlinking
+                        // This means path's target doesn't exist, stop unlinking
                         return currentTarget;
                     }
 
-                    //Check the new target path
+                    // Check the new target path
                     if (newTarget == destPath)
                     {
-                        //Throw an appropriate error
+                        // Throw an appropriate error
                         if (overwrite) throw new IOException(SR.Format(SR.IO_SharingViolation_File, destPath));
                         else throw new IOException(SR.Format(SR.IO_FileExists_Name, destPath));
                     }
 
-                    //Store the unlinked path, otherwise return our current path
+                    // Store the unlinked path, otherwise return our current path
                     if (string.IsNullOrEmpty(newTarget))
                     {
                         return currentTarget;
@@ -197,11 +197,11 @@ public static partial void CopyFile(string sourceFullPath, string destFullPath,
                     }
                 }
 
-                //If we get here, we've gone through MaxFollowedLinks iterations
+                // If we get here, we've gone through MaxFollowedLinks iterations
                 throw new IOException(SR.Format(SR.IO_TooManySymbolicLinkLevels, path));
             }
 
-            //Checks if a file or directory exists without caring which it was
+            // Checks if a file or directory exists without caring which it was
             static bool FileOrDirectoryExists(string path)
             {
                 return Interop.Sys.Stat(path, out _) >= 0;

diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.CopyFile.OtherUnix.cs b/src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.CopyFile.OtherUnix.cs
@@ -7,10 +7,10 @@ internal static partial class FileSystem
     {
         public static partial void CopyFile(string sourceFullPath, string destFullPath, bool overwrite)
         {
-            //Start the file copy and prepare for finalization
+            // Start the file copy and prepare for finalization
             using StartedCopyFileState startedCopyFile = StartCopyFile(sourceFullPath, destFullPath, overwrite);
 
-            //Copy the file using the standard unix implementation
+            // Copy the file using the standard unix implementation
             StandardCopyFile(startedCopyFile);
         }
     }

diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.Unix.cs
@@ -28,8 +28,8 @@ internal static partial class FileSystem
             UnixFileMode.OtherWrite |
             UnixFileMode.OtherExecute;
 
-        //Helper type to facilitate returning values from StartCopyFile without having
-        //to declare a massive tuple multiple times, and making it easier to dispose.
+        // Helper type to facilitate returning values from StartCopyFile without having
+        // to declare a massive tuple multiple times, and making it easier to dispose.
         private struct StartedCopyFileState : IDisposable
         {
             public long fileLength;
@@ -54,9 +54,9 @@ public void Dispose()
 
         private static StartedCopyFileState StartCopyFile(string sourceFullPath, string destFullPath, bool overwrite, bool openDst = true)
         {
-            //The return value is expected to be Disposed by the caller (unless this method throws) once the copy is complete.
-            //Begins 'CopyFile' by locking and creating the relevant file handles.
-            //If 'openDst' is false, it doesn't open the destination file handle, nor check anything to do with it (used in macOS implementation).
+            // The return value is expected to be Disposed by the caller (unless this method throws) once the copy is complete.
+            // Begins 'CopyFile' by locking and creating the relevant file handles.
+            // If 'openDst' is false, it doesn't open the destination file handle, nor check anything to do with it (used in macOS implementation).
 
             StartedCopyFileState startedCopyFile = default;
             try
@@ -70,15 +70,15 @@ private static StartedCopyFileState StartCopyFile(string sourceFullPath, string
                 throw;
             }
 
-            //Return the collection of information we have gotten back.
+            // Return the collection of information we have gotten back.
             return startedCopyFile;
         }
 
         private static SafeFileHandle? OpenCopyFileDstHandle(string destFullPath, bool overwrite, StartedCopyFileState startedCopyFile, bool openNewFile)
         {
-            //This function opens the 'dst' file handle for 'CopyFile', it is
-            //split out since the logic on OSX-like OSes is a bit different.
-            //'openNewFile' = false is used when we want to try to find the file only.
+            // This function opens the 'dst' file handle for 'CopyFile', it is
+            // split out since the logic on OSX-like OSes is a bit different.
+            // 'openNewFile' = false is used when we want to try to find the file only.
             if (!openNewFile)
             {
                 try
@@ -110,17 +110,17 @@ private static StartedCopyFileState StartCopyFile(string sourceFullPath, string
 
         private static void StandardCopyFile(StartedCopyFileState startedCopyFile)
         {
-            //Copy the file in a way that works on all Unix Operating Systems.
-            //The 'startedCopyFile' parameter should take the output from 'StartCopyFile'.
-            //'startedCopyFile' should be disposed by the caller. Assumes src and dst
-            //are non-null, caller must check this, return values from StartCopyFile
-            //are non-null (except dst when openDst is true), and from return values from
-            //OpenCopyFileDstHandle are non-null (except possibly when openNewFile is false).
+            // Copy the file in a way that works on all Unix Operating Systems.
+            // The 'startedCopyFile' parameter should take the output from 'StartCopyFile'.
+            // 'startedCopyFile' should be disposed by the caller. Assumes src and dst
+            // are non-null, caller must check this, return values from StartCopyFile
+            // are non-null (except dst when openDst is true), and from return values from
+            // OpenCopyFileDstHandle are non-null (except possibly when openNewFile is false).
             Interop.CheckIo(Interop.Sys.CopyFile(startedCopyFile.src!, startedCopyFile.dst!, startedCopyFile.fileLength));
         }
 
-        //CopyFile is defined in either FileSystem.CopyFile.OSX.cs or FileSystem.CopyFile.OtherUnix.cs
-        //The implementations on OSX-like Operating Systems attempts to clone the file first.
+        // CopyFile is defined in either FileSystem.CopyFile.OSX.cs or FileSystem.CopyFile.OtherUnix.cs
+        // The implementations on OSX-like Operating Systems attempts to clone the file first.
         public static partial void CopyFile(string sourceFullPath, string destFullPath, bool overwrite);
 
 #pragma warning disable IDE0060