Change how File/Directory/Link .delete works.

runtime/bin/directory_win.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_WINDOWS)
 
 #include "bin/directory.h"
+#include "bin/file.h"
 
 #include <errno.h>  // NOLINT
 #include <sys/stat.h>  // NOLINT
 
 #include "bin/log.h"
 
 class PathBuffer {
  public:
   PathBuffer() : length(0) {
     data = new wchar_t[MAX_PATH + 1];
@@ skipping 22 matching lines @@
       return false;
     }
   }
 
   void Reset(int new_length) {
     length = new_length;
     data[length] = L'\0';
   }
 };
 
+// If link_name points to a link, IsBrokenLink will return true if link_name
+// points to an invalid target.
+static bool IsBrokenLink(const wchar_t* link_name) {
+  HANDLE handle = CreateFileW(
+      link_name,
+      0,
+      FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+      NULL,
+      OPEN_EXISTING,
+      FILE_FLAG_BACKUP_SEMANTICS,
+      NULL);
+  if (handle == INVALID_HANDLE_VALUE) {
+    return true;
+  } else {
+    CloseHandle(handle);
+    return false;
+  }
+}
+
 
 // Forward declarations.
 static bool ListRecursively(PathBuffer* path,
                             bool recursive,
                             bool follow_links,
                             DirectoryListing* listing);
 static bool DeleteRecursively(PathBuffer* path);
 
 
 static void PostError(DirectoryListing* listing,
@@ skipping 54 matching lines @@
 static bool HandleEntry(LPWIN32_FIND_DATAW find_file_data,
                         PathBuffer* path,
                         bool recursive,
                         bool follow_links,
                         DirectoryListing* listing) {
   DWORD attributes = find_file_data->dwFileAttributes;
   if ((attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
     if (!follow_links) {
       return HandleLink(find_file_data->cFileName, path, listing);
     }
-    // Attempt to list the directory, to see if it's a valid link or not.
     int path_length = path->length;
     if (!path->Add(find_file_data->cFileName)) return false;
-    if (!path->Add(L"\\*")) return false;
-    WIN32_FIND_DATAW tmp_file_data;
-    HANDLE find_handle = FindFirstFileW(path->data, &tmp_file_data);
+    bool broken = IsBrokenLink(path->data);
     path->Reset(path_length);
-    if (find_handle == INVALID_HANDLE_VALUE) {
-      // Invalid handle, report as (broken) link.
+    if (broken) {
+      // Report as (broken) link.
       return HandleLink(find_file_data->cFileName, path, listing);
-    } else {
-      FindClose(find_handle);
     }
   }
   if ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
     return HandleDir(find_file_data->cFileName,
                      path,
                      recursive,
                      follow_links,
                      listing);
   } else {
     return HandleFile(find_file_data->cFileName, path, listing);
@@ skipping 99 matching lines @@
   }
 }
 
 
 static bool DeleteRecursively(PathBuffer* path) {
   // If the directory is a junction, it's pointing to some other place in the
   // filesystem that we do not want to recurse into.
   DWORD attributes = GetFileAttributesW(path->data);
   if ((attributes != INVALID_FILE_ATTRIBUTES) &&
       (attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
-    // Just delete the junction itself.
-    return RemoveDirectoryW(path->data) != 0;
+    if (IsBrokenLink(path->data)) {
+      return false;
+    } else {
+      // Just delete the junction itself.
+      return RemoveDirectoryW(path->data) != 0;
+    }
   }
 
   if (!path->Add(L"\\*")) return false;
 
   WIN32_FIND_DATAW find_file_data;
   HANDLE find_handle = FindFirstFileW(path->data, &find_file_data);
 
   // Adjust the path by removing the '*' used for the search.
   int path_length = path->length - 1;
   path->Reset(path_length);
@@ skipping 43 matching lines @@
         last_error == ERROR_PATH_NOT_FOUND) {
       return Directory::DOES_NOT_EXIST;
     } else {
       // We might not be able to get the file attributes for other
       // reasons such as lack of permissions. In that case we do
       // not know if the directory exists.
       return Directory::UNKNOWN;
     }
   }
   bool exists = (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
+  exists = exists && !IsBrokenLink(dir_name);
   return exists ? Directory::EXISTS : Directory::DOES_NOT_EXIST;
 }
 
 
 Directory::ExistsResult Directory::Exists(const char* dir_name) {
   const wchar_t* system_name = StringUtils::Utf8ToWide(dir_name);
   Directory::ExistsResult result = ExistsHelper(system_name);
   free(const_cast<wchar_t*>(system_name));
   return result;
 }
@@ skipping 69 matching lines @@
   }
   char* result = StringUtils::WideToUtf8(path.data);
   return result;
 }
 
 
 bool Directory::Delete(const char* dir_name, bool recursive) {
   bool result = false;
   const wchar_t* system_dir_name = StringUtils::Utf8ToWide(dir_name);
   if (!recursive) {
-    result = (RemoveDirectoryW(system_dir_name) != 0);
+    if (File::GetType(dir_name, true) == File::kIsDirectory) {
+      result = (RemoveDirectoryW(system_dir_name) != 0);
+    } else {
+      SetLastError(ERROR_DIRECTORY);
+    }
   } else {
     PathBuffer path;
-    if (!path.Add(system_dir_name)) {
-      return false;
+    if (path.Add(system_dir_name)) {
+      result = DeleteRecursively(&path);
     }
-    result = DeleteRecursively(&path);
   }
   free(const_cast<wchar_t*>(system_dir_name));
   return result;
 }
 
 
 bool Directory::Rename(const char* path, const char* new_path) {
   const wchar_t* system_path = StringUtils::Utf8ToWide(path);
   const wchar_t* system_new_path = StringUtils::Utf8ToWide(new_path);
   ExistsResult exists = ExistsHelper(system_path);
   if (exists != EXISTS) return false;
   ExistsResult new_exists = ExistsHelper(system_new_path);
   // MoveFile does not allow replacing exising directories. Therefore,
   // if the new_path is currently a directory we need to delete it
   // first.
   if (new_exists == EXISTS) {
     bool success = Delete(new_path, true);
     if (!success) return false;
   }
   DWORD flags = MOVEFILE_WRITE_THROUGH;
   int move_status =
       MoveFileExW(system_path, system_new_path, flags);
   free(const_cast<wchar_t*>(system_path));
   free(const_cast<wchar_t*>(system_new_path));
   return (move_status != 0);
 }
 
 #endif  // defined(TARGET_OS_WINDOWS)