1. move agenda topic
2. wait
3. reload page
4. hope the item is where it's supposed to be
5. GOTO 1

{
  let bar = foo1.bar;
  if (bar) { ... }
}
{
  let bar = foo2.bar;
  if (bar) { ... }
}

snek: I think this presentation didn't really cover all the contours. it's relevant that the proposal also includes an expression form:

if (let x = foo; condition(x)) {

} else {

}

if (let { data, error } = ...; data) {
  // use data 
}
else {
  // use error
}

let { data, error } = ...;
if (data) {
  // use data 
}
else {
  // use error
}

or if you really care about scope,

{
let { data, error } = ...;
if (data) {
  // use data 
}
else {
  // use error
}
}

dunno if Ben Lickly is in the chat, but the answer to the question is,

let match;
while ((match = tokenRegex.exec(input)) !== null) {
  // ...
}

vs

while (const match = tokenRegex.exec(input)) {
  // ...
}

better diagnostics argues for, but using argues against, and I think is much stronger (since for diagnostics you can of course just put the binding outside). I want to be able to write this, and have the resource be disposed before the else. I invite you to rewrite it assuming that the binding lives through the else. I can't make it pretty!

if (using resource = getResource(); resource.needsUpdate) {
  resource.update();
} else {
  await postMessage('no updates required');
}

best I've got is this:

let neededUpdate;
{
  using resource = getResource();
  if (resource.needsUpdate) {
    neededUpdate = true;
    resource.update();
  }
}
if (!neededUpdate) {
  await postMessage('no updates required');
}

Or with a helper function:

function getResourceIfNeedsUpdate() {
  using stack = new DisposableStack();
  const resource = stack.use(getResource());
  if (resource.needsUpdate) {
     stack.move();
     return resource;
  }
  return null;
}

if (using resource = getResourceIfNeedsUpdate()) {
  resource.update();
} else {
  await postMessage('no updates required');
}

Or more generalized:

function holdResourceIf(acquire, test) {
  using stack = new DisposableStack();
  const resource = stack.use(acquire());
  if (test(resource)) {
    stack.move();
    return resource;
  }
  return null;
}

if (using resource = holdResourceIf(() => getResource(), res => res.needsUpdate)) {
  ...
} else {
  ...
}

I don't think there's good use cases but personally I would not make it a syntax error; just leave it to linters. I can imagine someone wanting to write

let data = whatever;
if (let data = updateOrNull()) {
  console.log('updated', data);
} else {
  console.log('not updated', data);
}

or something. probably they shouldn't but I don't think it's the language's place to forbid this

let x = true;
if (let x = false) {} else {log(x)}

let e = 0;
try { throw 1; } catch (e) { console.log(e) } finally { console.log(e) }

that's just how bindings work!

for x in range(3):
    print(x)
else:
    print('Final x = %d' % (x))

if using had stuck with Java's try-with-resources then we might have a case. IIRC, In Java:

try (FileReader r = new FileReader(...)) {
  ...
}
catch (IOException e) {
  // r is not reachable
}

But control-flow based on exceptions isn't quite the same as if...else

for x in range(3):
  if x == 2: break
else
  print('not found')