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
|
discard """
output: '''
@[1, 2, 3]
Success
@["a", "b", "c"]
Hello
1
2
0
List
@["4", "5", "6", "", "", "a", ""]
@["", "", "a", ""]
'''
cmd: '''nim c --gc:arc $file'''
"""
import os
import math
import lists
import strutils
proc mkleak() =
# allocate 1 MB via linked lists
let numberOfLists = 100
for i in countUp(1, numberOfLists):
var leakList = initDoublyLinkedList[string]()
let numberOfLeaks = 5000
for j in countUp(1, numberOfLeaks):
leakList.append(newString(200))
proc mkManyLeaks() =
for i in 0..0:
mkleak()
echo "Success"
iterator foobar(c: string): seq[string] {.closure.} =
yield @["a", "b", c]
proc tsimpleClosureIterator =
var myc = "c"
for it in foobar(myc):
echo it
type
LazyList = ref object
c: proc() {.closure.}
proc tlazyList =
let dep = @[1, 2, 3]
var x = LazyList(c: proc () = echo(dep))
x.c()
type
Foo = ref object
proc tleakingNewStmt =
var x: Foo
for i in 0..10:
new(x)
iterator infinite(): int {.closure.} =
var i = 0
while true:
yield i
inc i
iterator take(it: iterator (): int, numToTake: int): int {.closure.} =
var i = 0
for x in it():
if i >= numToTake:
break
yield x
inc i
proc take3 =
for x in infinite.take(3):
discard
type
A = ref object of RootObj
x: int
B = ref object of A
more: string
proc inheritanceBug(param: string) =
var s: (A, A)
s[0] = B(more: "a" & param)
s[1] = B(more: "a" & param)
type
PAsyncHttpServer = ref object
value: string
proc serve(server: PAsyncHttpServer) = discard
proc leakObjConstr =
serve(PAsyncHttpServer(value: "asdas"))
let startMem = getOccupiedMem()
take3()
tlazyList()
inheritanceBug("whatever")
mkManyLeaks()
tsimpleClosureIterator()
tleakingNewStmt()
leakObjConstr()
# bug #12964
type
Token* = ref object of RootObj
Li* = ref object of Token
proc bug12964*() =
var token = Li()
var tokens = @[Token()]
tokens.add token
bug12964()
# bug #13119
import streams
proc bug13119 =
var m = newStringStream("Hello world")
let buffer = m.readStr(5)
echo buffer
m.close
bug13119()
# bug #13105
type
Result[T, E] = object
a: T
b: E
D = ref object
x: int
R = Result[D, int]
proc bug13105 =
for n in [R(b: 1), R(b: 2)]:
echo n.b
bug13105()
echo getOccupiedMem() - startMem
#------------------------------------------------------------------------------
# issue #14294
import tables
type
TagKind = enum
List = 0, Compound
Tag = object
case kind: TagKind
of List:
values: seq[Tag]
of Compound:
compound: Table[string, Tag]
var a = Tag(kind: List)
var b = a
echo a.kind
var c = a
proc testAdd(i: int; yyy: openArray[string]) =
var x: seq[string]
x.add [$i, $(i+1), $(i+2)]
x.add yyy
echo x
var y = newSeq[string](4)
y[2] = "a"
testAdd(4, y)
echo y
|
