2023-10-24 14:21:07 +00:00
|
|
|
import
|
2023-11-15 08:38:48 +00:00
|
|
|
std/[macros, sequtils],
|
2023-10-24 14:21:07 +00:00
|
|
|
../futures
|
|
|
|
|
2024-03-08 13:43:42 +00:00
|
|
|
{.push raises: [].}
|
|
|
|
|
2023-10-24 14:21:07 +00:00
|
|
|
type
|
|
|
|
InternalRaisesFuture*[T, E] = ref object of Future[T]
|
|
|
|
## Future with a tuple of possible exception types
|
|
|
|
## eg InternalRaisesFuture[void, (ValueError, OSError)]
|
|
|
|
##
|
2023-11-07 10:12:59 +00:00
|
|
|
## This type gets injected by `async: (raises: ...)` and similar utilities
|
|
|
|
## and should not be used manually as the internal exception representation
|
|
|
|
## is subject to change in future chronos versions.
|
|
|
|
|
|
|
|
proc makeNoRaises*(): NimNode {.compileTime.} =
|
|
|
|
# An empty tuple would have been easier but...
|
|
|
|
# https://github.com/nim-lang/Nim/issues/22863
|
|
|
|
# https://github.com/nim-lang/Nim/issues/22865
|
|
|
|
|
|
|
|
ident"void"
|
|
|
|
|
2024-01-04 15:17:42 +00:00
|
|
|
proc dig(n: NimNode): NimNode {.compileTime.} =
|
|
|
|
# Dig through the layers of type to find the raises list
|
|
|
|
if n.eqIdent("void"):
|
|
|
|
n
|
|
|
|
elif n.kind == nnkBracketExpr:
|
|
|
|
if n[0].eqIdent("tuple"):
|
|
|
|
n
|
|
|
|
elif n[0].eqIdent("typeDesc"):
|
|
|
|
dig(getType(n[1]))
|
|
|
|
else:
|
|
|
|
echo astGenRepr(n)
|
|
|
|
raiseAssert "Unkown bracket"
|
|
|
|
elif n.kind == nnkTupleConstr:
|
|
|
|
n
|
|
|
|
else:
|
|
|
|
dig(getType(getTypeInst(n)))
|
|
|
|
|
|
|
|
proc isNoRaises*(n: NimNode): bool {.compileTime.} =
|
|
|
|
dig(n).eqIdent("void")
|
|
|
|
|
|
|
|
iterator members(tup: NimNode): NimNode =
|
|
|
|
# Given a typedesc[tuple] = (A, B, C), yields the tuple members (A, B C)
|
|
|
|
if not isNoRaises(tup):
|
|
|
|
for n in getType(getTypeInst(tup)[1])[1..^1]:
|
|
|
|
yield n
|
|
|
|
|
|
|
|
proc members(tup: NimNode): seq[NimNode] {.compileTime.} =
|
|
|
|
for t in tup.members():
|
|
|
|
result.add(t)
|
|
|
|
|
|
|
|
macro hasException(raises: typedesc, ident: static string): bool =
|
|
|
|
newLit(raises.members.anyIt(it.eqIdent(ident)))
|
|
|
|
|
2023-11-15 08:38:48 +00:00
|
|
|
macro Raising*[T](F: typedesc[Future[T]], E: varargs[typedesc]): untyped =
|
|
|
|
## Given a Future type instance, return a type storing `{.raises.}`
|
|
|
|
## information
|
|
|
|
##
|
|
|
|
## Note; this type may change in the future
|
|
|
|
E.expectKind(nnkBracket)
|
|
|
|
|
|
|
|
let raises = if E.len == 0:
|
|
|
|
makeNoRaises()
|
|
|
|
else:
|
|
|
|
nnkTupleConstr.newTree(E.mapIt(it))
|
|
|
|
nnkBracketExpr.newTree(
|
|
|
|
ident "InternalRaisesFuture",
|
|
|
|
nnkDotExpr.newTree(F, ident"T"),
|
|
|
|
raises
|
|
|
|
)
|
|
|
|
|
|
|
|
template init*[T, E](
|
|
|
|
F: type InternalRaisesFuture[T, E], fromProc: static[string] = ""): F =
|
|
|
|
## Creates a new pending future.
|
|
|
|
##
|
|
|
|
## Specifying ``fromProc``, which is a string specifying the name of the proc
|
|
|
|
## that this future belongs to, is a good habit as it helps with debugging.
|
2024-01-04 15:17:42 +00:00
|
|
|
when not hasException(type(E), "CancelledError"):
|
|
|
|
static:
|
|
|
|
raiseAssert "Manually created futures must either own cancellation schedule or raise CancelledError"
|
|
|
|
|
|
|
|
|
2023-11-15 08:38:48 +00:00
|
|
|
let res = F()
|
|
|
|
internalInitFutureBase(res, getSrcLocation(fromProc), FutureState.Pending, {})
|
|
|
|
res
|
|
|
|
|
|
|
|
template init*[T, E](
|
|
|
|
F: type InternalRaisesFuture[T, E], fromProc: static[string] = "",
|
|
|
|
flags: static[FutureFlags]): F =
|
|
|
|
## Creates a new pending future.
|
|
|
|
##
|
|
|
|
## Specifying ``fromProc``, which is a string specifying the name of the proc
|
|
|
|
## that this future belongs to, is a good habit as it helps with debugging.
|
|
|
|
let res = F()
|
2024-01-04 15:17:42 +00:00
|
|
|
when not hasException(type(E), "CancelledError"):
|
|
|
|
static:
|
|
|
|
doAssert FutureFlag.OwnCancelSchedule in flags,
|
|
|
|
"Manually created futures must either own cancellation schedule or raise CancelledError"
|
|
|
|
|
2023-11-15 08:38:48 +00:00
|
|
|
internalInitFutureBase(
|
|
|
|
res, getSrcLocation(fromProc), FutureState.Pending, flags)
|
|
|
|
res
|
|
|
|
|
2023-10-24 14:21:07 +00:00
|
|
|
proc containsSignature(members: openArray[NimNode], typ: NimNode): bool {.compileTime.} =
|
|
|
|
let typHash = signatureHash(typ)
|
|
|
|
|
|
|
|
for err in members:
|
|
|
|
if signatureHash(err) == typHash:
|
|
|
|
return true
|
|
|
|
false
|
|
|
|
|
|
|
|
# Utilities for working with the E part of InternalRaisesFuture - unstable
|
2023-11-21 10:01:44 +00:00
|
|
|
macro prepend*(tup: typedesc, typs: varargs[typed]): typedesc =
|
2023-10-24 14:21:07 +00:00
|
|
|
result = nnkTupleConstr.newTree()
|
|
|
|
for err in typs:
|
|
|
|
if not tup.members().containsSignature(err):
|
|
|
|
result.add err
|
|
|
|
|
|
|
|
for err in tup.members():
|
|
|
|
result.add err
|
|
|
|
|
|
|
|
if result.len == 0:
|
2023-11-07 10:12:59 +00:00
|
|
|
result = makeNoRaises()
|
2023-10-24 14:21:07 +00:00
|
|
|
|
2023-11-21 10:01:44 +00:00
|
|
|
macro remove*(tup: typedesc, typs: varargs[typed]): typedesc =
|
2023-10-24 14:21:07 +00:00
|
|
|
result = nnkTupleConstr.newTree()
|
|
|
|
for err in tup.members():
|
|
|
|
if not typs[0..^1].containsSignature(err):
|
|
|
|
result.add err
|
|
|
|
|
|
|
|
if result.len == 0:
|
2023-11-07 10:12:59 +00:00
|
|
|
result = makeNoRaises()
|
2023-10-24 14:21:07 +00:00
|
|
|
|
2023-11-21 10:01:44 +00:00
|
|
|
macro union*(tup0: typedesc, tup1: typedesc): typedesc =
|
2023-10-24 14:21:07 +00:00
|
|
|
## Join the types of the two tuples deduplicating the entries
|
|
|
|
result = nnkTupleConstr.newTree()
|
|
|
|
|
|
|
|
for err in tup0.members():
|
|
|
|
var found = false
|
|
|
|
for err2 in tup1.members():
|
|
|
|
if signatureHash(err) == signatureHash(err2):
|
|
|
|
found = true
|
|
|
|
if not found:
|
|
|
|
result.add err
|
|
|
|
|
2024-03-05 12:53:12 +00:00
|
|
|
for err2 in tup1.members():
|
2023-10-24 14:21:07 +00:00
|
|
|
result.add err2
|
2023-11-07 10:12:59 +00:00
|
|
|
if result.len == 0:
|
|
|
|
result = makeNoRaises()
|
2023-10-24 14:21:07 +00:00
|
|
|
|
2023-11-15 08:38:48 +00:00
|
|
|
proc getRaisesTypes*(raises: NimNode): NimNode =
|
|
|
|
let typ = getType(raises)
|
|
|
|
case typ.typeKind
|
|
|
|
of ntyTypeDesc: typ[1]
|
|
|
|
else: typ
|
2023-10-24 14:21:07 +00:00
|
|
|
|
|
|
|
macro checkRaises*[T: CatchableError](
|
2023-11-15 08:38:48 +00:00
|
|
|
future: InternalRaisesFuture, raises: typed, error: ref T,
|
|
|
|
warn: static bool = true): untyped =
|
2023-10-24 14:21:07 +00:00
|
|
|
## Generate code that checks that the given error is compatible with the
|
|
|
|
## raises restrictions of `future`.
|
|
|
|
##
|
|
|
|
## This check is done either at compile time or runtime depending on the
|
|
|
|
## information available at compile time - in particular, if the raises
|
|
|
|
## inherit from `error`, we end up with the equivalent of a downcast which
|
|
|
|
## raises a Defect if it fails.
|
2023-11-15 08:38:48 +00:00
|
|
|
let
|
|
|
|
raises = getRaisesTypes(raises)
|
2023-10-24 14:21:07 +00:00
|
|
|
|
|
|
|
expectKind(getTypeInst(error), nnkRefTy)
|
|
|
|
let toMatch = getTypeInst(error)[0]
|
|
|
|
|
2023-11-15 08:38:48 +00:00
|
|
|
|
|
|
|
if isNoRaises(raises):
|
|
|
|
error(
|
|
|
|
"`fail`: `" & repr(toMatch) & "` incompatible with `raises: []`", future)
|
|
|
|
return
|
|
|
|
|
2023-10-24 14:21:07 +00:00
|
|
|
var
|
|
|
|
typeChecker = ident"false"
|
|
|
|
maybeChecker = ident"false"
|
|
|
|
runtimeChecker = ident"false"
|
|
|
|
|
|
|
|
for errorType in raises[1..^1]:
|
|
|
|
typeChecker = infix(typeChecker, "or", infix(toMatch, "is", errorType))
|
|
|
|
maybeChecker = infix(maybeChecker, "or", infix(errorType, "is", toMatch))
|
|
|
|
runtimeChecker = infix(
|
|
|
|
runtimeChecker, "or",
|
|
|
|
infix(error, "of", nnkBracketExpr.newTree(ident"typedesc", errorType)))
|
|
|
|
|
|
|
|
let
|
2023-11-07 10:12:59 +00:00
|
|
|
errorMsg = "`fail`: `" & repr(toMatch) & "` incompatible with `raises: " & repr(raises[1..^1]) & "`"
|
2023-10-24 14:21:07 +00:00
|
|
|
warningMsg = "Can't verify `fail` exception type at compile time - expected one of " & repr(raises[1..^1]) & ", got `" & repr(toMatch) & "`"
|
|
|
|
# A warning from this line means exception type will be verified at runtime
|
|
|
|
warning = if warn:
|
|
|
|
quote do: {.warning: `warningMsg`.}
|
|
|
|
else: newEmptyNode()
|
|
|
|
|
|
|
|
# Cannot check inhertance in macro so we let `static` do the heavy lifting
|
|
|
|
quote do:
|
|
|
|
when not(`typeChecker`):
|
|
|
|
when not(`maybeChecker`):
|
|
|
|
static:
|
|
|
|
{.error: `errorMsg`.}
|
|
|
|
else:
|
|
|
|
`warning`
|
|
|
|
assert(`runtimeChecker`, `errorMsg`)
|
2023-11-15 08:38:48 +00:00
|
|
|
|
2024-03-08 13:43:42 +00:00
|
|
|
func failed*[T](future: InternalRaisesFuture[T, void]): bool {.inline.} =
|
|
|
|
## Determines whether ``future`` finished with an error.
|
|
|
|
static:
|
|
|
|
warning("No exceptions possible with this operation, `failed` always returns false")
|
|
|
|
|
|
|
|
false
|
|
|
|
|
|
|
|
func error*[T](future: InternalRaisesFuture[T, void]): ref CatchableError {.
|
2023-11-15 08:38:48 +00:00
|
|
|
raises: [].} =
|
|
|
|
static:
|
|
|
|
warning("No exceptions possible with this operation, `error` always returns nil")
|
|
|
|
nil
|
|
|
|
|
2024-03-08 13:43:42 +00:00
|
|
|
func readError*[T](future: InternalRaisesFuture[T, void]): ref CatchableError {.
|
2023-11-15 08:38:48 +00:00
|
|
|
raises: [ValueError].} =
|
|
|
|
static:
|
|
|
|
warning("No exceptions possible with this operation, `readError` always raises")
|
|
|
|
raise newException(ValueError, "No error in future.")
|