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
|
discard """
matrix: "--mm:refc"
output: '''obj = (inner: (kind: Just, id: 7))
obj.inner.id = 7
id = 7
obj = (inner: (kind: Just, id: 7))
2
(a: "a", b: "b", c: "")
caught
(a: "a", b: "b", c: "")'''
"""
# bug #6960
import sugar
type
Kind = enum None, Just, Huge
Inner = object
case kind: Kind
of None: discard
of Just: id: int
of Huge: a,b,c,d,e,f: string
Outer = object
inner: Inner
proc shouldDoNothing(id: int): Inner =
dump id
Inner(kind: Just, id: id)
var obj = Outer(inner: Inner(kind: Just, id: 7))
dump obj
dump obj.inner.id
obj.inner = shouldDoNothing(obj.inner.id)
dump obj
import os
type
TStatusEnum* = enum
sUnknown = -1, sBuildFailure, sBuildInProgress, sBuildSuccess,
sTestFailure, sTestInProgress, sTestSuccess, # ORDER MATTERS!
sDocGenFailure, sDocGenInProgress, sDocGenSuccess,
sCSrcGenFailure, sCSrcGenInProgress, sCSrcGenSuccess
TStatus* = object
status*: TStatusEnum
desc*: string
hash*: string
proc initStatus*(): TStatus =
result.status = sUnknown
result.desc = ""
result.hash = ""
proc isInProgress*(status: TStatusEnum): bool =
return status in {sBuildInProgress, sTestInProgress, sDocGenInProgress,
sCSrcGenInProgress}
proc `$`*(status: TStatusEnum): string =
case status
of sBuildFailure:
return "build failure"
of sBuildInProgress:
return "build in progress"
of sBuildSuccess:
return "build finished"
of sTestFailure:
return "testing failure"
of sTestInProgress:
return "testing in progress"
of sTestSuccess:
return "testing finished"
of sDocGenFailure:
return "documentation generation failed"
of sDocGenInProgress:
return "generating documentation"
of sDocGenSuccess:
return "documentation generation succeeded"
of sCSrcGenFailure:
return "csource generation failed"
of sCSrcGenInProgress:
return "csource generation in progress"
of sCSrcGenSuccess:
return "csource generation succeeded"
of sUnknown:
return "unknown"
proc makeCommitPath*(platform, hash: string): string =
return platform / "nim_" & hash.substr(0, 11) # 11 Chars.
type
TFlag = enum
A, B, C, D
TFlags = set[TFlag]
TObj = object
x: int
flags: TFlags
# have a proc taking TFlags as param and returning object having TFlags field
proc foo(flags: TFlags): TObj = nil
# bug #5137
type
MyInt {.importc: "int".} = object
MyIntDistinct = distinct MyInt
proc bug5137(d: MyIntDistinct) =
discard d.MyInt
#-------------------------------------
# bug #8979
type
MyKind = enum
Fixed, Float
MyObject = object
someInt: int
case kind: MyKind
of Float: index: string
of Fixed: nil
MyResult = object
val: array[0..1, string]
vis: set[0..1]
import macros
func myfunc(obj: MyObject): MyResult {.raises: [].} =
template index: auto =
case obj.kind:
of Float: $obj.index
of Fixed: "Fixed"
macro to_str(a: untyped): string =
result = newStrLitNode(a.repr)
result.val[0] = index
result.val[1] = to_str(obj.kind + Ola)
let x = MyObject(someInt: 10, kind: Fixed)
echo myfunc(x).val.len
# bug #14126
type X = object
a, b, c: string
proc f(): X =
result.a = "a"
result.b = "b"
raise (ref ValueError)()
proc ohmanNoNRVO =
var x: X
x.a = "1"
x.b = "2"
x.c = "3"
try:
x = f()
except:
discard
echo x
# once NVRO is sorted out, x.c == "3"
doAssert x.c == "", "shouldn't modify x if f raises"
ohmanNoNRVO()
proc ohmanNoNRVO2(x: var X) =
x.a = "1"
x.c = "3"
x = f()
var xgg: X
try:
ohmanNoNRVO2(xgg)
except:
echo "caught"
echo xgg
# once NVRO is sorted out, xgg.c == "3"
doAssert xgg.c == "", "this assert will fail"
|