@nish I'm looking for a more automated approach, so that when the high-level wrapper goes out of scope/gets deleted, it automatically unrefs/frees the gobject CPointer. Objects could potentially be long-lived as well (assigned to properties, for example), and could outlive a simple scoped block.

ibelieve: even longer living objects still have some natural lifetime, (ab)using memory management for resource management is generally not a very good idea (i.e. http://www.oracle.com/technetwork/articles/java/finalization-137655.html and similar). Maybe investing some effort into rethinking the desired behavior could make your bindings more easily usable?

What about something like

this.myThing = wrappedLibrary.objectA.objectB.objectC.objectD.theThing

when accessing a foreign object system from Kotlin, e.g. GObject, COM, Python, ...? You would want all the intermediate wrapped objects (

objectA

,

objectB

, ...) destroyed as soon as possible (perhaps scoped to the block) but

theThing

to be left alive.

class ExternalObject(val id: Int) {
    fun addRef() = println("addref on $id")
    fun release() = println("release on $id")
}

interface ObjectOwner {
    fun addObject(obj: ExternalObject)
    fun addOwner(owner: ObjectOwner)
    fun clear()
}

fun ObjectOwner.makeObject(id: Int): ExternalObject {
    val result = ExternalObject(id)
    this.addObject(result)
    return result
}

open class Holder : ObjectOwner {
    val objects = mutableListOf<ExternalObject>()
    val owners = mutableListOf<ObjectOwner>()

    constructor(parent: ObjectOwner? = null) {
        if (parent != null) parent.addOwner(this)
    }

    override fun addObject(obj: ExternalObject): Unit {
        // If we want more aggressive release strategy, we can use MutableSet for `objects`
        // and release ASAP.
        objects.add(obj)
        obj.addRef()
    }

    override fun addOwner(owner: ObjectOwner): Unit {
        owners.add(owner)
    }

    override fun clear() {
        for (obj in objects) obj.release()
        for (owner in owners) owner.clear()
    }
}

class FieldOwner(parent: ObjectOwner) : Holder(parent) {

    var objectField: ExternalObject? = null
        set(value: ExternalObject?) {
            field = value
            if (value != null) addObject(value)
        }

        get() = field
}


inline fun <T> scoped(block: ObjectOwner.() -> T): T {
    val scope = Holder()
    try {
        return scope.block()
    } finally {
        scope.clear()
    }
}

fun main(args: Array<String>) {
    scoped {
        val owner = FieldOwner(this)
        owner.objectField = makeObject(1)
        scoped {
            owner.objectField = makeObject(3)

        }
        owner.objectField = makeObject(2)
    }
}

shows how one could think of such a cases