std/dirs: progress (#1502)

Author: Araq

doc/stdlib.dgn.md

@@ -1195,6 +1195,64 @@ Returns the absolute path of `path`, rooted at `root` (which must be absolute; d
 Expands `~` or a path starting with `~/` to a full path, replacing `~` with getHomeDir() (otherwise returns `path` unmodified). Windows: this is still supported despite the Windows platform not having this convention.
 
 
+### dirs
+
+@../lib/std/dirs.nim
+
+This module implements operations for creating, removing, and iterating over directories.
+
+
+####tryCreateFinalDir
+
+Tries to create the final directory in a path. In other words, it tries to create a single new directory, not a nested one. It returns the OS's error code making it easy to distinguish between "could not create" and "already exists".
+
+####createDir
+
+Creates a new directory `dir`. If the directory already exists, no error is raised. This can be used to create a nested directory structure directly.
+
+####tryRemoveFinalDir
+
+Tries to remove the final directory in a path. In other words, it tries to remove a single directory, not a nested one. It returns the OS's error code making it easy to distinguish between "could not remove" and "does not exist".
+
+####removeDir
+
+Removes the directory `dir`. If the directory does not exist, no error is raised.
+
+
+####tryRemoveFile
+
+Tries to remove the file. It returns the OS's error code making it easy to distinguish between "could not remove" and "does not exist".
+
+####removeFile
+
+Removes the file `file`. If the file did not exist, no error is raised.
+
+
+####walkDir
+
+Walks over all entries in the directory `dir`.
+
+Yields tuples of `(kind, path)` where `kind` is one of:
+- `pcFile` - regular file
+- `pcDir` - directory
+- `pcLinkToFile` - symbolic link to a file
+- `pcLinkToDir` - symbolic link to a directory
+
+If `relative` is true, yields relative paths (just the filename/dirname), otherwise yields full paths.
+
+If `checkDir` is true, raises an error if `dir` doesn't exist or isn't a directory.
+
+Special directories "." and ".." are skipped.
+
+
+####getCurrentDir
+Returns the current working directory as a `Path`. Raises an error if unable to retrieve the current directory.
+
+####setCurrentDir
+Sets the current working directory to `dir`. Raises an error if the directory does not exist or lacks permissions.
+
+
+
 ### appdirs
 
 @../lib/std/appdirs.nim

lib/std/dirs.nim

@@ -1,4 +1,4 @@
-## This module implements directory operations for creating, removing,
+## This module implements operations for creating, removing,
 ## and iterating over directories.
 ##
 ## **See also:**
@@ -14,7 +14,7 @@ export paths.Path, paths.initPath, paths.`/`, paths.`$`
 
 when defined(windows):
   import windows/winlean
-  from widestrs import newWideCString, toWideCString
+  from widestrs import newWideCString, toWideCString, `$`
 
 else:
   import posix/posix
@@ -100,10 +100,125 @@ proc removeFile*(file: Path) {.raises.} =
   else:
     raise res
 
-#[
+type
+  DirEntry* = object
+    kind*: PathComponent
+    path*: Path
+
+  DirWalker* = object
+    when defined(windows):
+      wimpl: WIN32_FIND_DATA
+      handle: Handle
+    else:
+      pimpl: ptr DIR
+    dir: Path
+    status: ErrorCode
+
+proc tryOpenDir*(dir: sink Path): DirWalker =
+  ## Tries to open the directory `dir` for iteration over its entries.
+  result = DirWalker(dir: dir, status: EmptyError)
+  when defined(windows):
+    var dirStr = $result.dir & "\\*"
+    result.handle = findFirstFileW(newWideCString(dirStr).rawData, result.wimpl)
+    if result.handle == INVALID_HANDLE_VALUE:
+      result.status = windowsToErrorCode getLastError()
+    else:
+      result.status = Success
+  else:
+    var dirStr = $result.dir
+    result.pimpl = opendir(dirStr.toCString)
+    if result.pimpl == nil:
+      result.status = posixToErrorCode(errno)
+    else:
+      result.status = Success
+
+proc fillDirEntry(w: var DirWalker; e: var DirEntry) =
+  when defined(windows):
+    let isDir = (w.wimpl.dwFileAttributes.uint32 and FILE_ATTRIBUTE_DIRECTORY) != 0'u32
+    let isLink = (w.wimpl.dwFileAttributes.uint32 and FILE_ATTRIBUTE_REPARSE_POINT) != 0'u32
+
+    var kind: PathComponent
+    if isLink:
+      kind = if isDir: pcLinkToDir else: pcLinkToFile
+    else:
+      kind = if isDir: pcDir else: pcFile
+    e.kind = kind
+    let f = cast[ptr UncheckedArray[WinChar]](addr w.wimpl.cFileName)
+    e.path = paths.initPath($f)
+
+when defined(posix):
+  proc pathComponentFromEntry(w: var DirWalker; name: string; dType: uint8): PathComponent =
+    if dType == DT_UNKNOWN or dType == DT_LNK:
+      var fullPath = concat($w.dir, "/", name)
+      var s = default Stat
+      if lstat(fullPath.toCString, s) == 0:
+        if S_ISLNK(s.st_mode):
+          # For symlinks, we need to check if they point to a directory
+          var targetStat = default Stat
+          if stat(fullPath.toCString, targetStat) == 0 and S_ISDIR(targetStat.st_mode):
+            result = pcLinkToDir
+          else:
+            result = pcLinkToFile
+        elif S_ISDIR(s.st_mode):
+          result = pcDir
+        else:
+          result = pcFile
+    elif dType == DT_DIR:
+      result = pcDir
+    else:
+      result = pcFile
+
+proc tryNextDir*(w: var DirWalker; e: var DirEntry): bool =
+  when defined(windows):
+    while w.status == Success:
+      if findNextFileW(w.handle, w.wimpl) != 0'i32:
+        if skipFindData(w.wimpl):
+          discard "skip entry"
+        else:
+          break
+      else:
+        # do not overwrite first error
+        if w.status == Success:
+          w.status = windowsToErrorCode getLastError()
+        break
+    result = w.status == Success
+    if result:
+      fillDirEntry(w, e)
+  else:
+    while w.status == Success:
+      let entry = readdir(w.pimpl)
+      if entry == nil:
+        if w.status == Success:
+          w.status = posixToErrorCode(errno)
+        result = false
+        break
+      else:
+        result = true
+        let cstr = cast[cstring](addr entry.d_name[0])
+        let name = fromCString cstr
+        # Skip "." and ".."
+        if name == "." or name == "..":
+          discard "skip"
+        else:
+          e.kind = pathComponentFromEntry(w, name, entry.d_type)
+          e.path = initPath(name)
+          break
+
+proc tryCloseDir*(w: var DirWalker): ErrorCode =
+  when defined(windows):
+    if findClose(w.handle).isSuccess:
+      result = Success
+    else:
+      result = windowsToErrorCode getLastError()
+  else:
+    if closedir(w.pimpl) == 0'i32:
+      result = Success
+    else:
+      result = posixToErrorCode(errno)
+
 iterator walkDir*(dir: Path,
                   relative = false,
-                  checkDir = false): tuple[kind: PathComponent, path: Path] =
+                  checkDir = false): tuple[kind: PathComponent, path: Path] {.raises.} =
   ## Walks over all entries in the directory `dir`.
   ##
   ## Yields tuples of `(kind, path)` where `kind` is one of:
@@ -118,86 +233,20 @@ iterator walkDir*(dir: Path,
   ## If `checkDir` is true, raises an error if `dir` doesn't exist or isn't a directory.
   ##
   ## Special directories "." and ".." are skipped.
-  ##
-  ## See also:
-  ## * `walkDirRec iterator`_
-  ## * `dirExists proc <oscommons.html#dirExists,string>`_
-  when defined(windows):
-    var findData: WIN32_FIND_DATA
-    var dirStr = $dir
-    let searchPath = dirStr & (when defined(windows): '\\' else: '/') & "*"
-    let handle = findFirstFile(searchPath, findData)
-    if handle == INVALID_HANDLE_VALUE:
-      if checkDir:
-        raiseOSError(osLastError())
-    else:
-      defer:
-        discard findClose(handle)
-
-      while true:
-        if not skipFindData(findData):
-          # Use same pattern as oscommons for getting filename
-          var filename = ""
-          var i = 0
-          while findData.cFileName[i].int16 != 0'i16:
-            filename.add char(findData.cFileName[i].int and 0xFF)
-            inc i
-
-          let fullPath = if relative: initPath(filename) else: dir / initPath(filename)
-
-          let isDir = (findData.dwFileAttributes.uint32 and FILE_ATTRIBUTE_DIRECTORY) != 0'u32
-          let isLink = (findData.dwFileAttributes.uint32 and FILE_ATTRIBUTE_REPARSE_POINT) != 0'u32
-
-          var kind: PathComponent
-          if isLink:
-            kind = if isDir: pcLinkToDir else: pcLinkToFile
-          else:
-            kind = if isDir: pcDir else: pcFile
-
-          yield (kind, fullPath)
-
-        if findNextFileW(handle, findData) == 0'i32:
-          break
-
-  else: # POSIX
-    var dirStr = $dir
-    let d = opendir(dirStr.toCString)
-    if d == nil:
-      if checkDir:
-        raiseOSError(osLastError())
-    else:
-      defer:
-        discard closedir(d)
-
-      while true:
-        let entry = readdir(d)
-        if entry == nil:
-          break
-
-        let name = $cast[cstring](addr entry.d_name[0])
-        # Skip "." and ".."
-        if name == "." or name == "..":
-          continue
-
-        let fullPath = if relative:
-          initPath(name)
-        else:
-          dir / initPath(name)
-
-        let fullPathStr = $fullPath
-        # Determine the kind
-        if symlinkExists(fullPathStr):
-          let (pc, _) = getSymlinkFileKind(fullPathStr)
-          yield (pc, fullPath)
-        elif dirExists(fullPathStr):
-          yield (pcDir, fullPath)
-        elif fileExists(fullPathStr):
-          yield (pcFile, fullPath)
-        else:
-          # Unknown type, treat as file
-          yield (pcFile, fullPath)
-
-]#
+  var w = tryOpenDir(dir)
+  if checkDir and w.status != Success:
+    raise w.status
+  try:
+    var e = default DirEntry
+    while w.status == Success:
+      if tryNextDir(w, e):
+        let rel = if relative: e.path else: dir / e.path
+        yield (e.kind, rel)
+      else:
+        break
+  finally:
+    let res = tryCloseDir(w)
+    if checkDir and res != Success: raise res
 
 proc getCurrentDir*(): Path {.raises.} =
   ## Returns the current working directory as a `Path`.

lib/std/posix/posix.nim

@@ -119,6 +119,7 @@ when defined(posix):
   type
     DIR* {.importc: "DIR", header: "<dirent.h>".} = object
     Dirent* {.importc: "struct dirent", header: "<dirent.h>".} = object
+      d_type* {.importc: "d_type".}: uint8
       d_name* {.importc: "d_name".}: array[256, char]
 
   proc opendir*(name: cstring): ptr DIR {.importc, header: "<dirent.h>", sideEffect.}
@@ -128,3 +129,15 @@ when defined(posix):
   proc mkdir*(path: cstring, mode: Mode): cint {.importc, header: "<sys/stat.h>", sideEffect.}
   proc rmdir*(path: cstring): cint {.importc, header: "<unistd.h>", sideEffect.}
   proc unlink*(path: cstring): cint {.importc, header: "<unistd.h>", sideEffect.}
+
+  # POSIX d_type constants
+  const
+    DT_UNKNOWN* = 0'u8 ## Unknown file type.
+    DT_FIFO* = 1'u8    ## Named pipe, or FIFO.
+    DT_CHR* = 2'u8     ## Character device.
+    DT_DIR* = 4'u8     ## Directory.
+    DT_BLK* = 6'u8     ## Block device.
+    DT_REG* = 8'u8     ## Regular file.
+    DT_LNK* = 10'u8    ## Symbolic link.
+    DT_SOCK* = 12'u8   ## UNIX domain socket.
+    DT_WHT* = 14'u8

src/hexer/destroyer.nim

@@ -340,17 +340,14 @@ proc trTry(c: var Context; n: var Cursor) =
     skip nn
   copyInto(c.dest, n):
     let fin = if nn.substructureKind == FinU: nn.firstSon else: default(Cursor)
-    trNestedScope c, n, (if hasExcept: OtherPreventFinally else: Other), fin
+    trNestedScope c, n, OtherPreventFinally, fin
     while n.substructureKind == ExceptU:
       copyInto(c.dest, n):
         takeTree c.dest, n # `E as e`
         trNestedScope c, n, Other, fin
     if n.substructureKind == FinU:
-      if hasExcept:
-        copyInto(c.dest, n):
-          trNestedScope c, n
-      else:
-        skip n
+      copyInto(c.dest, n):
+        trNestedScope c, n
 
 proc tr(c: var Context; n: var Cursor) =
   if isAtom(n) or isDeclarative(n):

src/nimony/sem.nim

@@ -2558,8 +2558,13 @@ proc semFor(c: var SemContext; it: var Item) =
       var n2 = it.n
       skip n2
       let hasMultiVars = n2.kind != ParRi
-      if hasMultiVars and iterCall.typ.skipModifier.typeKind == TupleT:
-        semForLoopTupleVar c, it, iterCall.typ
+      if hasMultiVars:
+        if iterCall.typ.skipModifier.typeKind == TupleT:
+          semForLoopTupleVar c, it, iterCall.typ
+        else:
+          # error handling
+          while it.n.kind != ParRi:
+            semForLoopVar c, it, c.types.autoType
       else:
         semForLoopVar c, it, iterCall.typ