unsafeAddr => addr (stdlib)

lib/impure/db_sqlite.nim

@@ -121,7 +121,7 @@
 ##     var id = 1
 ##     ## Data needs to be converted to seq[byte] to be interpreted as binary by bindParams
 ##     var dbuf = newSeq[byte](orig.len*sizeof(float64))
-##     copyMem(unsafeAddr(dbuf[0]), unsafeAddr(orig[0]), dbuf.len)
+##     copyMem(addr(dbuf[0]), addr(orig[0]), dbuf.len)
 ##
 ##     ## Use prepared statement to insert binary data into database
 ##     var insertStmt = db.prepare("INSERT INTO test (id, data) VALUES (?, ?)")
@@ -138,7 +138,7 @@
 ##     let seqSize = int(dataTest.len*sizeof(byte)/sizeof(float64))
 ##     ## Copy binary string data in dataTest into a seq
 ##     var res: seq[float64] = newSeq[float64](seqSize)
-##     copyMem(unsafeAddr(res[0]), addr(dataTest[0]), dataTest.len)
+##     copyMem(addr(res[0]), addr(dataTest[0]), dataTest.len)
 ##
 ##     ## Check datas obtained is identical
 ##     doAssert res == orig
@@ -827,7 +827,7 @@ proc bindParam*(ps: SqlPrepared, paramIdx: int,val: openArray[byte], copy = true
   ## binds a blob to the specified paramIndex.
   ## if copy is true then SQLite makes its own private copy of the data immediately
   let len = val.len
-  if bind_blob(ps.PStmt, paramIdx.int32, val[0].unsafeAddr, len.int32, if copy: SQLITE_TRANSIENT else: SQLITE_STATIC) != SQLITE_OK:
+  if bind_blob(ps.PStmt, paramIdx.int32, val[0].addr, len.int32, if copy: SQLITE_TRANSIENT else: SQLITE_STATIC) != SQLITE_OK:
     dbBindParamError(paramIdx, val)
 
 macro bindParams*(ps: SqlPrepared, params: varargs[untyped]): untyped {.since: (1, 3).} =

lib/impure/re.nim

@@ -122,7 +122,7 @@ proc bufSubstr(b: cstring, sPos, ePos: int): string {.inline.} =
   ## Don't assume cstring is '\0' terminated
   let sz = ePos - sPos
   result = newString(sz+1)
-  copyMem(addr(result[0]), unsafeAddr(b[sPos]), sz)
+  copyMem(addr(result[0]), addr(b[sPos]), sz)
   result.setLen(sz)
 
 proc matchOrFind(buf: cstring, pattern: Regex, matches: var openArray[string],
@@ -427,7 +427,7 @@ iterator findAll*(buf: cstring, pattern: Regex, start = 0, bufSize: int): string
     let b = rawMatches[1]
     if a == b and a == i: break
     var str = newString(b-a)
-    copyMem(str[0].addr, unsafeAddr(buf[a]), b-a)
+    copyMem(str[0].addr, addr(buf[a]), b-a)
     yield str
     i = b
 

lib/pure/asyncdispatch.nim

@@ -1920,7 +1920,7 @@ proc send*(socket: AsyncFD, data: string,
   ## data has been sent.
   var retFuture = newFuture[void]("send")
   if data.len > 0:
-    let sendFut = socket.send(unsafeAddr data[0], data.len, flags)
+    let sendFut = socket.send(addr data[0], data.len, flags)
     sendFut.callback =
       proc () =
         keepAlive(data)

lib/pure/base64.nim

@@ -138,7 +138,7 @@ template encodeImpl() {.dirty.} =
       encodeInternal(s, lookupTableVM)
   else:
     block:
-      let lookupTable = if safe: unsafeAddr(cb64safe) else: unsafeAddr(cb64)
+      let lookupTable = if safe: addr(cb64safe) else: addr(cb64)
       encodeInternal(s, lookupTable)
 
 proc encode*[T: SomeInteger|char](s: openArray[T], safe = false): string =

lib/pure/hashes.nim

@@ -324,7 +324,7 @@ proc murmurHash(x: openArray[byte]): Hash =
         dec j
         k1 = (k1 shl 8) or (ord(x[i+j])).uint32
     else:
-      k1 = cast[ptr uint32](unsafeAddr x[i])[]
+      k1 = cast[ptr uint32](addr x[i])[]
     inc i, stepSize
 
     k1 = imul(k1, c1)

lib/pure/nativesockets.nim

@@ -663,7 +663,7 @@ when useNimNetLite:
       return ""
 
   proc sockAddrToStr(sa: var Sockaddr_in | var Sockaddr_in6): string =
-    result = sockAddrToStr(cast[ptr SockAddr](unsafeAddr(sa)))
+    result = sockAddrToStr(cast[ptr SockAddr](addr(sa)))
 
   proc getAddrString*(sockAddr: ptr SockAddr): string =
     result = sockAddrToStr(sockAddr)

lib/pure/net.nim

@@ -484,14 +484,14 @@ proc toSockAddr*(address: IpAddress, port: Port, sa: var Sockaddr_storage,
     let s = cast[ptr Sockaddr_in](addr sa)
     s.sin_family = typeof(s.sin_family)(toInt(AF_INET))
     s.sin_port = port
-    copyMem(addr s.sin_addr, unsafeAddr address.address_v4[0],
+    copyMem(addr s.sin_addr, addr address.address_v4[0],
             sizeof(s.sin_addr))
   of IpAddressFamily.IPv6:
     sl = sizeof(Sockaddr_in6).SockLen
     let s = cast[ptr Sockaddr_in6](addr sa)
     s.sin6_family = typeof(s.sin6_family)(toInt(AF_INET6))
     s.sin6_port = port
-    copyMem(addr s.sin6_addr, unsafeAddr address.address_v6[0],
+    copyMem(addr s.sin6_addr, addr address.address_v6[0],
             sizeof(s.sin6_addr))
 
 proc fromSockAddrAux(sa: ptr Sockaddr_storage, sl: SockLen,
@@ -516,7 +516,7 @@ proc fromSockAddr*(sa: Sockaddr_storage | SockAddr | Sockaddr_in | Sockaddr_in6,
     sl: SockLen, address: var IpAddress, port: var Port) {.inline.} =
   ## Converts `SockAddr` and `SockLen` to `IpAddress` and `Port`. Raises
   ## `ObjectConversionDefect` in case of invalid `sa` and `sl` arguments.
-  fromSockAddrAux(cast[ptr Sockaddr_storage](unsafeAddr sa), sl, address, port)
+  fromSockAddrAux(cast[ptr Sockaddr_storage](addr sa), sl, address, port)
 
 when defineSsl:
   CRYPTO_malloc_init()

lib/pure/streams.nim

@@ -333,15 +333,15 @@ proc write*[T](s: Stream, x: T) =
   ##
   ## .. code-block:: Nim
   ##
-  ##     s.writeData(s, unsafeAddr(x), sizeof(x))
+  ##     s.writeData(s, addr(x), sizeof(x))
   runnableExamples:
     var strm = newStringStream("")
     strm.write("abcde")
     strm.setPosition(0)
     doAssert strm.readAll() == "abcde"
     strm.close()
 
-  writeData(s, unsafeAddr(x), sizeof(x))
+  writeData(s, addr(x), sizeof(x))
 
 proc write*(s: Stream, x: string) =
   ## Writes the string `x` to the stream `s`. No length field or
@@ -1196,7 +1196,7 @@ else: # after 1.3 or JS not defined
       jsOrVmBlock:
         buffer[slice.a..<slice.a+result] = s.data[s.pos..<s.pos+result]
       do:
-        copyMem(unsafeAddr buffer[slice.a], addr s.data[s.pos], result)
+        copyMem(addr buffer[slice.a], addr s.data[s.pos], result)
       inc(s.pos, result)
     else:
       result = 0

lib/pure/strutils.nim

@@ -1875,7 +1875,7 @@ func find*(s: string, sub: char, start: Natural = 0, last = 0): int {.rtl,
     when hasCStringBuiltin:
       let L = last-start+1
       if L > 0:
-        let found = c_memchr(s[start].unsafeAddr, sub, cast[csize_t](L))
+        let found = c_memchr(s[start].addr, sub, cast[csize_t](L))
         if not found.isNil:
           return cast[ByteAddress](found) -% cast[ByteAddress](s.cstring)
     else:
@@ -1928,7 +1928,7 @@ func find*(s, sub: string, start: Natural = 0, last = 0): int {.rtl,
     else:
       when hasCStringBuiltin:
         if last == 0 and s.len > start:
-          let found = c_strstr(s[start].unsafeAddr, sub)
+          let found = c_strstr(s[start].addr, sub)
           if not found.isNil:
             result = cast[ByteAddress](found) -% cast[ByteAddress](s.cstring)
           else:

lib/std/private/digitsutils.nim

@@ -31,7 +31,7 @@ const
 proc utoa2Digits*(buf: var openArray[char]; pos: int; digits: uint32) {.inline.} =
   buf[pos] = digits100[2 * digits]
   buf[pos+1] = digits100[2 * digits + 1]
-  #copyMem(buf, unsafeAddr(digits100[2 * digits]), 2 * sizeof((char)))
+  #copyMem(buf, addr(digits100[2 * digits]), 2 * sizeof((char)))
 
 proc trailingZeros2Digits*(digits: uint32): int32 {.inline.} =
   return trailingZeros100[digits]
@@ -49,7 +49,7 @@ func addChars[T](result: var string, x: T, start: int, n: int) {.inline.} =
     when defined(js) or defined(nimscript): impl
     else:
       {.noSideEffect.}:
-        copyMem result[old].addr, x[start].unsafeAddr, n
+        copyMem result[old].addr, x[start].addr, n
 
 func addChars[T](result: var string, x: T) {.inline.} =
   addChars(result, x, 0, x.len)

lib/std/sha1.nim

@@ -152,7 +152,7 @@ proc update*(ctx: var Sha1State, data: openArray[char]) =
   # Gather 64-bytes worth of data in order to perform a round with the leftover
   # data we had stored (but not processed yet)
   if len > 64 - i:
-    copyMem(addr ctx.buf[i], unsafeAddr data[j], 64 - i)
+    copyMem(addr ctx.buf[i], addr data[j], 64 - i)
     len -= 64 - i
     j += 64 - i
     transform(ctx)
@@ -161,7 +161,7 @@ proc update*(ctx: var Sha1State, data: openArray[char]) =
     i = 0
   # Process the bulk of the payload
   while len >= 64:
-    copyMem(addr ctx.buf[0], unsafeAddr data[j], 64)
+    copyMem(addr ctx.buf[0], addr data[j], 64)
     len -= 64
     j += 64
     transform(ctx)

lib/system/ansi_c.nim

@@ -111,11 +111,11 @@ elif defined(nimBuiltinSetjmp):
     proc c_builtin_longjmp(jmpb: ptr pointer, retval: cint) {.
       importc: "__builtin_longjmp", nodecl.}
     # The second parameter needs to be 1 and sometimes the C/C++ compiler checks it.
-    c_builtin_longjmp(unsafeAddr jmpb[0], 1)
+    c_builtin_longjmp(addr jmpb[0], 1)
   proc c_setjmp*(jmpb: C_JmpBuf): cint =
     proc c_builtin_setjmp(jmpb: ptr pointer): cint {.
       importc: "__builtin_setjmp", nodecl.}
-    c_builtin_setjmp(unsafeAddr jmpb[0])
+    c_builtin_setjmp(addr jmpb[0])
 elif defined(nimRawSetjmp) and not defined(nimStdSetjmp):
   when defined(windows):
     # No `_longjmp()` on Windows.

lib/system/atomics.nim

@@ -308,7 +308,7 @@ static int __tcc_cas(int *ptr, int oldVal, int newVal)
     tcc_cas(cast[ptr int](p), cast[int](oldValue), cast[int](newValue))
 elif declared(atomicCompareExchangeN):
   proc cas*[T: bool|int|ptr](p: ptr T; oldValue, newValue: T): bool =
-    atomicCompareExchangeN(p, oldValue.unsafeAddr, newValue, false, ATOMIC_SEQ_CST, ATOMIC_SEQ_CST)
+    atomicCompareExchangeN(p, oldValue.addr, newValue, false, ATOMIC_SEQ_CST, ATOMIC_SEQ_CST)
 else:
   # this is valid for GCC and Intel C++
   proc cas*[T: bool|int|ptr](p: ptr T; oldValue, newValue: T): bool

lib/system/channels_builtin.nim

@@ -366,7 +366,7 @@ proc sendImpl(q: PRawChannel, typ: PNimType, msg: pointer, noBlock: bool): bool
 
 proc send*[TMsg](c: var Channel[TMsg], msg: sink TMsg) {.inline.} =
   ## Sends a message to a thread. `msg` is deeply copied.
-  discard sendImpl(cast[PRawChannel](addr c), cast[PNimType](getTypeInfo(msg)), unsafeAddr(msg), false)
+  discard sendImpl(cast[PRawChannel](addr c), cast[PNimType](getTypeInfo(msg)), addr(msg), false)
   when defined(gcDestructors):
     wasMoved(msg)
 
@@ -377,7 +377,7 @@ proc trySend*[TMsg](c: var Channel[TMsg], msg: sink TMsg): bool {.inline.} =
   ##
   ## Returns `false` if the message was not sent because number of pending items
   ## in the channel exceeded `maxItems`.
-  result = sendImpl(cast[PRawChannel](addr c), cast[PNimType](getTypeInfo(msg)), unsafeAddr(msg), true)
+  result = sendImpl(cast[PRawChannel](addr c), cast[PNimType](getTypeInfo(msg)), addr(msg), true)
   when defined(gcDestructors):
     if result:
       wasMoved(msg)

lib/system/io.nim

@@ -251,7 +251,7 @@ when defined(windows):
           break
         inc i
       else:
-        let w = c_fprintf(f, "%s", unsafeAddr s[i])
+        let w = c_fprintf(f, "%s", addr s[i])
         if w <= 0:
           if doRaise: raiseEIO("cannot write string to file")
           break
@@ -896,7 +896,7 @@ proc writeFile*(filename: string, content: openArray[byte]) {.since: (1, 1).} =
   var f: File = nil
   if open(f, filename, fmWrite):
     try:
-      f.writeBuffer(unsafeAddr content[0], content.len)
+      f.writeBuffer(addr content[0], content.len)
     finally:
       close(f)
   else:

lib/system/repr_v2.nim

@@ -90,7 +90,7 @@ proc repr*(p: pointer): string =
 
 proc repr*(p: proc): string =
   ## repr of a proc as its address
-  repr(cast[ptr pointer](unsafeAddr p)[])
+  repr(cast[ptr pointer](addr p)[])
 
 template repr*(x: distinct): string =
   repr(distinctBase(typeof(x))(x))

lib/system/sets.nim

@@ -18,7 +18,7 @@ proc cardSet(s: NimSet, len: int): int {.compilerproc, inline.} =
   result = 0
   when defined(x86) or defined(amd64):
     while i < len - 8:
-      inc(result, countBits64((cast[ptr uint64](s[i].unsafeAddr))[]))
+      inc(result, countBits64((cast[ptr uint64](s[i].addr))[]))
       inc(i, 8)
 
   while i < len:

lib/system/strmantle.nim

@@ -17,7 +17,7 @@ proc cmpStrings(a, b: string): int {.inline, compilerproc.} =
   let blen = b.len
   let minlen = min(alen, blen)
   if minlen > 0:
-    result = c_memcmp(unsafeAddr a[0], unsafeAddr b[0], cast[csize_t](minlen))
+    result = c_memcmp(addr a[0], addr b[0], cast[csize_t](minlen))
     if result == 0:
       result = alen - blen
   else:
@@ -28,7 +28,7 @@ proc eqStrings(a, b: string): bool {.inline, compilerproc.} =
   let blen = b.len
   if alen == blen:
     if alen == 0: return true
-    return equalMem(unsafeAddr(a[0]), unsafeAddr(b[0]), alen)
+    return equalMem(addr(a[0]), addr(b[0]), alen)
 
 proc hashString(s: string): int {.compilerproc.} =
   # the compiler needs exactly the same hash function!

lib/system/strs_v2.nim

@@ -51,7 +51,7 @@ proc prepareAdd(s: var NimStringV2; addlen: int) {.compilerRtl.} =
     s.p.cap = newLen
     if s.len > 0:
       # we are about to append, so there is no need to copy the \0 terminator:
-      copyMem(unsafeAddr s.p.data[0], unsafeAddr oldP.data[0], min(s.len, newLen))
+      copyMem(addr s.p.data[0], addr oldP.data[0], min(s.len, newLen))
   else:
     let oldCap = s.p.cap and not strlitFlag
     if newLen > oldCap:
@@ -80,7 +80,7 @@ proc toNimStr(str: cstring, len: int): NimStringV2 {.compilerproc.} =
     p.cap = len
     if len > 0:
       # we are about to append, so there is no need to copy the \0 terminator:
-      copyMem(unsafeAddr p.data[0], str, len)
+      copyMem(addr p.data[0], str, len)
     result = NimStringV2(len: len, p: p)
 
 proc cstrToNimstr(str: cstring): NimStringV2 {.compilerRtl.} =
@@ -89,12 +89,12 @@ proc cstrToNimstr(str: cstring): NimStringV2 {.compilerRtl.} =
 
 proc nimToCStringConv(s: NimStringV2): cstring {.compilerproc, nonReloadable, inline.} =
   if s.len == 0: result = cstring""
-  else: result = cstring(unsafeAddr s.p.data)
+  else: result = cstring(addr s.p.data)
 
 proc appendString(dest: var NimStringV2; src: NimStringV2) {.compilerproc, inline.} =
   if src.len > 0:
     # also copy the \0 terminator:
-    copyMem(unsafeAddr dest.p.data[dest.len], unsafeAddr src.p.data[0], src.len+1)
+    copyMem(addr dest.p.data[dest.len], addr src.p.data[0], src.len+1)
     inc dest.len, src.len
 
 proc appendChar(dest: var NimStringV2; c: char) {.compilerproc, inline.} =
@@ -153,7 +153,7 @@ proc nimAsgnStrV2(a: var NimStringV2, b: NimStringV2) {.compilerRtl.} =
         a.p = cast[ptr NimStrPayload](alloc0(contentSize(b.len)))
       a.p.cap = b.len
     a.len = b.len
-    copyMem(unsafeAddr a.p.data[0], unsafeAddr b.p.data[0], b.len+1)
+    copyMem(addr a.p.data[0], addr b.p.data[0], b.len+1)
 
 proc nimPrepareStrMutationImpl(s: var NimStringV2) =
   let oldP = s.p
@@ -163,7 +163,7 @@ proc nimPrepareStrMutationImpl(s: var NimStringV2) =
   else:
     s.p = cast[ptr NimStrPayload](alloc0(contentSize(s.len)))
   s.p.cap = s.len
-  copyMem(unsafeAddr s.p.data[0], unsafeAddr oldP.data[0], s.len+1)
+  copyMem(addr s.p.data[0], addr oldP.data[0], s.len+1)
 
 proc nimPrepareStrMutationV2(s: var NimStringV2) {.compilerRtl, inline.} =
   if s.p != nil and (s.p.cap and strlitFlag) == strlitFlag:
@@ -173,5 +173,5 @@ proc prepareMutation*(s: var string) {.inline.} =
   # string literals are "copy on write", so you need to call
   # `prepareMutation` before modifying the strings via `addr`.
   {.cast(noSideEffect).}:
-    let s = unsafeAddr s
+    let s = addr s
     nimPrepareStrMutationV2(cast[ptr NimStringV2](s)[])

lib/system/sysstr.nim

@@ -163,7 +163,7 @@ proc addChar(s: NimString, c: char): NimString =
       when defined(nimIncrSeqV3):
         result = rawNewStringNoInit(r)
         result.len = s.len
-        copyMem(addr result.data[0], unsafeAddr(s.data[0]), s.len+1)
+        copyMem(addr result.data[0], addr(s.data[0]), s.len+1)
       else:
         result = cast[NimString](growObj(result,
           sizeof(TGenericSeq) + r + 1))
@@ -213,7 +213,7 @@ proc resizeString(dest: NimString, addlen: int): NimString {.compilerRtl.} =
     when defined(nimIncrSeqV3):
       result = rawNewStringNoInit(sp)
       result.len = dest.len
-      copyMem(addr result.data[0], unsafeAddr(dest.data[0]), dest.len+1)
+      copyMem(addr result.data[0], addr(dest.data[0]), dest.len+1)
     else:
       result = cast[NimString](growObj(dest, sizeof(TGenericSeq) + sp + 1))
     result.reserved = sp
@@ -242,7 +242,7 @@ proc setLengthStr(s: NimString, newLen: int): NimString {.compilerRtl.} =
     when defined(nimIncrSeqV3):
       result = rawNewStringNoInit(sp)
       result.len = s.len
-      copyMem(addr result.data[0], unsafeAddr(s.data[0]), s.len+1)
+      copyMem(addr result.data[0], addr(s.data[0]), s.len+1)
       zeroMem(addr result.data[s.len], newLen - s.len)
       result.reserved = sp
     else: