mirror of
https://github.com/nim-lang/Nim.git
synced 2026-01-02 11:12:37 +00:00
186 lines
3.2 KiB
Nim
186 lines
3.2 KiB
Nim
discard """
|
|
output: '''
|
|
assign
|
|
destroy
|
|
destroy
|
|
5
|
|
123
|
|
destroy Foo: 123
|
|
destroy Foo: 5
|
|
(x1: (val: ...))
|
|
destroy
|
|
---------------
|
|
app begin
|
|
(val: ...)
|
|
destroy
|
|
app end
|
|
'''
|
|
joinable: false
|
|
"""
|
|
|
|
# bug #2821
|
|
|
|
type T = object
|
|
|
|
proc `=`(lhs: var T, rhs: T) =
|
|
echo "assign"
|
|
|
|
proc `=destroy`(v: var T) =
|
|
echo "destroy"
|
|
|
|
proc use(x: T) = discard
|
|
|
|
proc usedToBeBlock =
|
|
var v1 = T()
|
|
var v2: T = v1
|
|
discard addr(v2) # prevent cursorfication
|
|
use v1
|
|
|
|
usedToBeBlock()
|
|
|
|
# bug #1632
|
|
|
|
type
|
|
Foo = object of RootObj
|
|
x: int
|
|
|
|
proc `=destroy`(a: var Foo) =
|
|
echo "destroy Foo: " & $a.x
|
|
|
|
template toFooPtr(a: int{lit}): ptr Foo =
|
|
var temp = Foo(x:a)
|
|
temp.addr
|
|
|
|
proc test(a: ptr Foo) =
|
|
echo a[].x
|
|
|
|
proc main =
|
|
test(toFooPtr(5))
|
|
test(toFooPtr(123))
|
|
|
|
main()
|
|
|
|
# bug #11517
|
|
type
|
|
UniquePtr*[T] = object
|
|
val: ptr T
|
|
|
|
proc `=destroy`*[T](p: var UniquePtr[T]) =
|
|
mixin `=destroy`
|
|
echo "destroy"
|
|
if p.val != nil:
|
|
`=destroy`(p.val[])
|
|
dealloc(p.val)
|
|
p.val = nil
|
|
|
|
proc `=`*[T](dest: var UniquePtr[T], src: UniquePtr[T]) {.error.}
|
|
|
|
proc `=sink`*[T](dest: var UniquePtr[T], src: UniquePtr[T]) {.inline.} =
|
|
if dest.val != src.val:
|
|
if dest.val != nil:
|
|
`=destroy`(dest)
|
|
dest.val = src.val
|
|
|
|
proc newUniquePtr*[T](val: sink T): UniquePtr[T] =
|
|
result.val = create(T)
|
|
result.val[] = val
|
|
|
|
#-------------------------------------------------------------
|
|
|
|
type
|
|
MyObject = object of RootObj
|
|
x1: UniquePtr[int]
|
|
|
|
MyObject2 = object of MyObject
|
|
|
|
proc newObj2(x:int, y: float): MyObject2 =
|
|
MyObject2(x1: newUniquePtr(x))
|
|
|
|
proc test =
|
|
let obj2 = newObj2(1, 1.0)
|
|
echo obj2
|
|
|
|
test()
|
|
|
|
|
|
#------------------------------------------------------------
|
|
# Issue #12883
|
|
|
|
type
|
|
TopObject = object
|
|
internal: UniquePtr[int]
|
|
|
|
proc deleteTop(p: ptr TopObject) =
|
|
if p != nil:
|
|
`=destroy`(p[]) # !!! this operation used to leak the integer
|
|
deallocshared(p)
|
|
|
|
proc createTop(): ptr TopObject =
|
|
result = cast[ptr TopObject](allocShared0(sizeof(TopObject)))
|
|
result.internal = newUniquePtr(1)
|
|
|
|
proc test2() =
|
|
let x = createTop()
|
|
echo $x.internal
|
|
deleteTop(x)
|
|
|
|
echo "---------------"
|
|
echo "app begin"
|
|
test2()
|
|
echo "app end"
|
|
|
|
# bug #14601
|
|
|
|
when true: # D20200607T202043
|
|
type Foo2 = object
|
|
x: int
|
|
x2: array[10, int]
|
|
|
|
type Vec = object
|
|
vals: seq[Foo2]
|
|
|
|
proc `=destroy`*(a: var Foo2) {.inline.} =
|
|
discard
|
|
|
|
proc initFoo2(x: int): Foo2 = Foo2(x: x)
|
|
|
|
proc add2(v: var Vec, a: Foo2) = # ditto with `a: sink Foo2`
|
|
v.vals.add a
|
|
|
|
proc add3(v: var Vec, a: Foo2) = # ditto with `a: sink Foo2`
|
|
v.vals = @[a]
|
|
|
|
proc add4(v: var Vec, a: sink Foo2) = # ditto with `a: sink Foo2`
|
|
v.vals.add a
|
|
|
|
proc add5(v: var Vec, a: sink Foo2) = # ditto with `a: sink Foo2`
|
|
v.vals = @[a]
|
|
|
|
proc main2()=
|
|
var a: Vec
|
|
var b = Foo2(x: 10)
|
|
a.add2 b # ok
|
|
a.vals.add Foo2(x: 10) # ok
|
|
a.add2 initFoo2(x = 10) # ok
|
|
a.add2 Foo2(x: 10) # bug
|
|
a.add3 initFoo2(x = 10) # ok
|
|
a.add3 Foo2(x: 10) # bug
|
|
a.add4 initFoo2(x = 10) # ok
|
|
a.add4 Foo2(x: 10) # bug
|
|
a.add5 initFoo2(x = 10) # ok
|
|
a.add5 Foo2(x: 10) # bug
|
|
main2()
|
|
|
|
|
|
|
|
#------------------------------------------------------------
|
|
# Issue #15825
|
|
|
|
type
|
|
Union = string | int | char
|
|
|
|
proc run(a: sink Union) =
|
|
discard
|
|
|
|
run("123")
|