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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
import macros
block:
template myAttr() {.pragma.}
proc myProc():int {.myAttr.} = 2
const hasMyAttr = myProc.hasCustomPragma(myAttr)
static:
assert(hasMyAttr)
block:
template myAttr(a: string) {.pragma.}
type MyObj = object
myField1, myField2 {.myAttr: "hi".}: int
var o: MyObj
static:
assert o.myField2.hasCustomPragma(myAttr)
assert(not o.myField1.hasCustomPragma(myAttr))
import custom_pragma
block: # A bit more advanced case
type
Subfield {.defaultValue: "catman".} = object
c* {.serializationKey: "cc".}: float
MySerializable = object
a {.serializationKey"asdf", defaultValue: 5.} : int
b {.custom_pragma.defaultValue"hello".} : int
field: Subfield
d {.alternativeKey("df", 5).}: float
e {.alternativeKey(V = 5).}: seq[bool]
proc myproc(x: int, s: string) {.alternativeKey(V = 5), serializationKey"myprocSS".} =
echo x, s
var s: MySerializable
const aDefVal = s.a.getCustomPragmaVal(defaultValue)
static: assert(aDefVal == 5)
const aSerKey = s.a.getCustomPragmaVal(serializationKey)
static: assert(aSerKey == "asdf")
const cSerKey = getCustomPragmaVal(s.field.c, serializationKey)
static: assert(cSerKey == "cc")
const procSerKey = getCustomPragmaVal(myproc, serializationKey)
static: assert(procSerKey == "myprocSS")
static: assert(hasCustomPragma(myproc, alternativeKey))
const hasFieldCustomPragma = s.field.hasCustomPragma(defaultValue)
static: assert(hasFieldCustomPragma == false)
# pragma on an object
static:
assert Subfield.hasCustomPragma(defaultValue)
assert(Subfield.getCustomPragmaVal(defaultValue) == "catman")
assert hasCustomPragma(type(s.field), defaultValue)
block: # ref types
type
Node = object of RootObj
left {.serializationKey:"l".}, right {.serializationKey:"r".}: NodeRef
NodeRef = ref Node
NodePtr = ptr Node
SpecialNodeRef = ref object of NodeRef
data {.defaultValue"none".}: string
MyFile {.defaultValue: "closed".} = ref object
path {.defaultValue: "invalid".}: string
TypeWithoutPragma = object
var s = NodeRef()
const
leftSerKey = getCustomPragmaVal(s.left, serializationKey)
rightSerKey = getCustomPragmaVal(s.right, serializationKey)
static:
assert leftSerKey == "l"
assert rightSerKey == "r"
var specS = SpecialNodeRef()
const
dataDefVal = hasCustomPragma(specS.data, defaultValue)
specLeftSerKey = hasCustomPragma(specS.left, serializationKey)
static:
assert dataDefVal == true
assert specLeftSerKey == true
var ptrS = NodePtr(nil)
const
ptrRightSerKey = getCustomPragmaVal(ptrS.right, serializationKey)
static:
assert ptrRightSerKey == "r"
var f = MyFile()
const
fileDefVal = f.getCustomPragmaVal(defaultValue)
filePathDefVal = f.path.getCustomPragmaVal(defaultValue)
static:
assert fileDefVal == "closed"
assert filePathDefVal == "invalid"
static:
assert TypeWithoutPragma.hasCustomPragma(defaultValue) == false
block:
type
VariantKind = enum
variInt,
variFloat
variString
variNestedCase
Variant = object
case kind: VariantKind
of variInt: integer {.serializationKey: "int".}: BiggestInt
of variFloat: floatp: BiggestFloat
of variString: str {.serializationKey: "string".}: string
of variNestedCase:
case nestedKind: VariantKind
of variInt..variNestedCase: nestedItem {.defaultValue: "Nimmers of the world, unite!".}: int
let vari = Variant(kind: variInt)
const
hasIntSerKey = vari.integer.hasCustomPragma(serializationKey)
strSerKey = vari.str.getCustomPragmaVal(serializationKey)
nestedItemDefVal = vari.nestedItem.getCustomPragmaVal(defaultValue)
static:
assert hasIntSerKey
assert strSerKey == "string"
assert nestedItemDefVal == "Nimmers of the world, unite!"
block:
template simpleAttr {.pragma.}
type Annotated {.simpleAttr.} = object
proc generic_proc[T]() =
assert Annotated.hasCustomPragma(simpleAttr)
#--------------------------------------------------------------------------
# Pragma on proc type
let a: proc(x: int) {.defaultValue(5).} = nil
static:
doAssert hasCustomPragma(a.type, defaultValue)
# bug #8371
template thingy {.pragma.}
type
Cardinal = enum
north, east, south, west
Something = object
a: float32
case cardinal: Cardinal
of north:
b {.thingy.}: int
of east:
c: int
of south: discard
else: discard
var foo: Something
foo.cardinal = north
doAssert foo.b.hasCustomPragma(thingy) == true
proc myproc(s: string): int =
{.thingy.}:
s.len
doAssert myproc("123") == 3
let xx = compiles:
proc myproc_bad(s: string): int =
{.not_exist.}:
s.len
doAssert: xx == false
macro checkSym(s: typed{nkSym}): untyped =
let body = s.getImpl.body
doAssert body[1].kind == nnkPragmaBlock
doAssert body[1][0].kind == nnkPragma
doAssert body[1][0][0] == bindSym"thingy"
checkSym(myproc)
|