Use cases:
* We want to break out some code to a separate function,
  but there are outbound gotos or accesses to local variables.
* We want to inline some recurring pattern (with access to
  gotos and local variables).

Goals:
* Avoid deep indentation and large functions.
* Isolate interface/implementation so the function can be type-checked etc.
  on it's own (but not necessarily compiled, since needs to be inlined).
* Make it clear which variables are used/modified and not.

Syntax ideas:
Option 1 (simple paste):

    snippet swap_if_nonzero(int someparam)
    using var int somevar
    using var int othervar
    using goto end
    using return int {
        if someparam == 0 goto error
        if somevar == 0 return -1
        int tmp = somevar
        somevar = othervar
        othervar = tmp
    }

    func f(int x) -> int {
        var int somevar
        var int othervar
        ...
        paste swap_if_nonzero(x)
        return somevar
      error:
        ...
    }

Option 2 ("function" paste):

    snippet swap_if_nonzero(int someparam) -> int
    using var int somevar
    using var int othervar
    using goto end {
        if someparam == 0 goto error
        if somevar == 0 return -1
        int tmp = somevar
        somevar = othervar
        othervar = tmp
        return somevar
    }

    func f(int x) -> int {
        var int somevar
        var int othervar
        ...
        return paste swap_if_nonzero(x)
      error:
        ...
    }

Option 3 (typed paste):

    snippet type swapsnippet(int someparam)
    using var int somevar
    using var int othervar
    using goto end
    using return int

    snippet swapsnippet swap_if_nonzero
        if someparam == 0 goto error
        if somevar == 0 return -1
        int tmp = somevar
        somevar = othervar
        othervar = tmp
    }

    func f(int x) -> int {
        var int somevar
        var int othervar
        ...
        paste swap_if_nonzero(x)
        return somevar
      error:
        ...
    }