Does the usage of closures lead to programmers inadvertently extending the lifetime of objects and if so is it a significant problem?

As an alternative I am considering the possibility of auto-destruction semantics for closures. The idea is that if a nested function or code-block object refers to a variable, its lifetime becomes tied to the lifetime of the shortest lived object to which it refers. This approach means that closures can be passed to functions, but not returned from a function. However functions can still be passed from functions. So in a sense what I would be doing is somewhat limiting the usefulness of closures, but at the same time limiting the associated expenses.

  Does the absense of proper closures (and GC) make
  it significantly more difficult or even impossible
  to express certain abstractions?

void repeat(function f, int n) {
  while (n > 0) {
    f();  
    --n; 
  }
}
 
void test()
{
  int x;
  void increment_x() { 
    ++x;
  }
  repeat(increment_x, 42);
  write(x); 
}

{
  object o;
  flubber(o);
} // o is always destroyed here