Borrowed locals, calls and fixes

Borrowed locals

A local is borrowed when it is ref r = x;, var p = &x;, a typed T* or a ref T r local, or a var that takes a native pointer from a call. A native pointer to a handle type is not borrowed. A pointer field of a native class with a weak source is a checked pointer, not a borrowed value (see “Pointer fields” in borrowing.md). A lambda that uses a borrowed local gives the capture error.

A ref local has more rules about its lifetime. A ref cannot bind to a temporary. A ref to a container element must not live over a shape change of the container, such as push_back. A ref cannot cross an await. A ref return must return a place that outlives the call. These rules are always errors. See “Lifetime of a ref” in Type design.

using "Actor.h"; using "Armory.h";
class Scan : Actor {
    void Run(ref Armory a, ref Vec3 pos) {
        var p = &pos;                    // borrowed: address
        ref r = pos.x;                  // borrowed: reference
        var best = a.Best();             // borrowed: native Weapon*
        var copy = r;                    // a value ...
        var ok = () => { var v = copy; };  // ... so a lambda can capture it
    }
}

Known gaps of the checker: a call can still store its borrowed argument in a collection that a field holds, for example items.push_back(&a) where items is a field of a pointer collection type. The checker does not follow a native call into the callee. a lambda that captures an iterator (var it = xs.begin();) or an std.optional<T&> is not found.

Borrowed values in calls

A borrowed value is valid for the whole call. Every call form takes it as an argument. The callee must not keep it.

var p = c ? &a : &b; and var q = (Vec3*)&a; are borrowed locals, like var p = &a;.

A call can return a pointer or a reference to its argument. The translator does not follow this alias. A var that takes a native pointer from a call is borrowed. A var that takes a reference from a call is a copy. Do not store the result of such a call.

using "Actor.h"; using "Util.h";
class Probe {
    void Take(Vec3* p) { }
    void See(ref Vec3 v) { }
    float Run(ref Vec3 v, Vec3* p, bool c) {
        if (p == null) return 0;
        Vec3 a; Vec3 b;
        Take(c ? &a : &b);              // every call form takes it ...
        See(*(c ? &a : &b));
        var f = (ref Vec3 w) => { See(w); };
        f(v);
        return Distance(v, *p);
    }                                   // ... but nothing keeps it
}

Escape hatch

hotc --no-strict-borrowed makes the field, return, collection element, &x and pointer lambda capture findings warnings. The backends have strict_borrowed = false. These stay errors: all rules of “Lifetime of a ref” (including a ref lambda capture), a T* of a script class, &h on a handle, this to a T& and a move-only field.

Quick fixes