1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
#
#
# Nim's Runtime Library
# (c) Copyright 2022 Nim contributors
#
# See the file "copying.txt", included in this
# distribution, for details about the copyright.
#
## This module implements assertion handling.
when not declared(sysFatal):
include "system/fatal"
import std/private/miscdollars
# ---------------------------------------------------------------------------
# helpers
type InstantiationInfo = tuple[filename: string, line: int, column: int]
proc `$`(info: InstantiationInfo): string =
# The +1 is needed here
# instead of overriding `$` (and changing its meaning), consider explicit name.
result = ""
result.toLocation(info.filename, info.line, info.column + 1)
# ---------------------------------------------------------------------------
when not defined(nimHasSinkInference):
{.pragma: nosinks.}
proc raiseAssert*(msg: string) {.noinline, noreturn, nosinks.} =
## Raises an `AssertionDefect` with `msg`.
sysFatal(AssertionDefect, msg)
proc failedAssertImpl*(msg: string) {.raises: [], tags: [].} =
## Raises an `AssertionDefect` with `msg`, but this is hidden
## from the effect system. Called when an assertion failed.
# trick the compiler to not list `AssertionDefect` when called
# by `assert`.
# xxx simplify this pending bootstrap >= 1.4.0, after which cast not needed
# anymore since `Defect` can't be raised.
type Hide = proc (msg: string) {.noinline, raises: [], noSideEffect, tags: [].}
cast[Hide](raiseAssert)(msg)
template assertImpl(cond: bool, msg: string, expr: string, enabled: static[bool]) =
when enabled:
const
loc = instantiationInfo(fullPaths = compileOption("excessiveStackTrace"))
ploc = $loc
bind instantiationInfo
mixin failedAssertImpl
{.line: loc.}:
if not cond:
failedAssertImpl(ploc & " `" & expr & "` " & msg)
template assert*(cond: untyped, msg = "") =
## Raises `AssertionDefect` with `msg` if `cond` is false. Note
## that `AssertionDefect` is hidden from the effect system, so it doesn't
## produce `{.raises: [AssertionDefect].}`. This exception is only supposed
## to be caught by unit testing frameworks.
##
## No code will be generated for `assert` when passing `-d:danger` (implied by `--assertions:off`).
## See `command line switches <nimc.html#compiler-usage-commandminusline-switches>`_.
runnableExamples: assert 1 == 1
runnableExamples("--assertions:off"):
assert 1 == 2 # no code generated, no failure here
runnableExamples("-d:danger"): assert 1 == 2 # ditto
assertImpl(cond, msg, astToStr(cond), compileOption("assertions"))
template doAssert*(cond: untyped, msg = "") =
## Similar to `assert <#assert.t,untyped,string>`_ but is always turned on regardless of `--assertions`.
runnableExamples:
doAssert 1 == 1 # generates code even when built with `-d:danger` or `--assertions:off`
assertImpl(cond, msg, astToStr(cond), true)
template onFailedAssert*(msg, code: untyped): untyped {.dirty.} =
## Sets an assertion failure handler that will intercept any assert
## statements following `onFailedAssert` in the current scope.
runnableExamples:
type MyError = object of CatchableError
lineinfo: tuple[filename: string, line: int, column: int]
# block-wide policy to change the failed assert exception type in order to
# include a lineinfo
onFailedAssert(msg):
raise (ref MyError)(msg: msg, lineinfo: instantiationInfo(-2))
doAssertRaises(MyError): doAssert false
when not defined(nimHasTemplateRedefinitionPragma):
{.pragma: redefine.}
template failedAssertImpl(msgIMPL: string): untyped {.dirty, redefine.} =
let msg = msgIMPL
code
template doAssertRaises*(exception: typedesc, code: untyped) =
## Raises `AssertionDefect` if specified `code` does not raise `exception`.
runnableExamples:
doAssertRaises(ValueError): raise newException(ValueError, "Hello World")
doAssertRaises(CatchableError): raise newException(ValueError, "Hello World")
doAssertRaises(AssertionDefect): doAssert false
var wrong = false
const begin = "expected raising '" & astToStr(exception) & "', instead"
const msgEnd = " by: " & astToStr(code)
template raisedForeign {.gensym.} = raiseAssert(begin & " raised foreign exception" & msgEnd)
when Exception is exception:
try:
if true:
code
wrong = true
except Exception as e: discard
except: raisedForeign()
else:
try:
if true:
code
wrong = true
except exception:
discard
except Exception as e:
mixin `$` # alternatively, we could define $cstring in this module
raiseAssert(begin & " raised '" & $e.name & "'" & msgEnd)
except: raisedForeign()
if wrong:
raiseAssert(begin & " nothing was raised" & msgEnd)
|