[Bug]: Cannot catch error thrown from nested throwing iterator

[jabraham17]

The following program compiles and runs, but the exception thrown by the second iter these cannot be caught.

record R {
  iter these(start) throws {
    var x = start;
    while true {
      yield x;
      if x == 0 {
        break;
      }
      throw new Error();
      x -= 1;
    }
  }
  iter these() throws {
    for e in this.these(10) do yield e;
  }
}

proc main() {

  var r = new R();

  try {
    for i in r.these(5) {
      writeln(i);
    }
  } catch e {
    writeln("Caught Exception: ", e); // this print works, the exception can be caught
  }

  try {
    for i in r {
      writeln(i);
    }
  } catch e {
    writeln("Caught Exception: ", e); // this print never is called, the exception cannot be caught
  }

}

This program results in the following output

5
Caught Exception: Error: 
10
uncaught Error: 
  bug.chpl:33: thrown here
  bug.chpl:33: uncaught here

This is maybe not that surprising, considering Chapel's limited support for throwing iterators. See #15089, #7134, and #26478

[jabraham17]

I spent some time looking into this and come up with some other reproducers

iter iterA() throws {
  yield 1;
  throw new Error("Error in iterA");
}

iter iterB() throws {
  // try {
  for e in iterA() {
    yield e;
  }
  // } catch e { throw e; }
}

iter iterC() throws  {
  for i in 1..10 {
    yield i;
    throw new Error("Error in iterC");
  }
}


proc main() {
  try {
    for i in iterA() {
      writeln(i);
    }
  } catch e {
    writeln("Caught Exception: ", e);
  }
  try {
    for i in iterC() {
      writeln(i);
    }
  } catch e {
    writeln("Caught Exception: ", e);
  }

  try {
    for i in iterB() {
      writeln(i);
    }
  } catch e {
    writeln("Caught Exception: ", e); // will never be called, iterB crashes and halts
  }
}

The exception thrown from iterB (originally from iterA) cannot be caught. iterB does seem to be getting created correctly, but then is messed up during inlining. I was able to trace this error to the lowerIterators pass, when out error formals are replaced with propagation to the enclosing error handling scope (see replaceErrorFormalWithEnclosingError). However, the compiler fails to identify a valid place to inline the error formal, so it inserts a chpl_uncaught_error instead (i.e. an uncatchable/fatal error). If I put an explicit try/catch/rethrow inside iterB, everything works nicely and the compiler can figure things out.

So while its nice that the compiler handles this case without crashing, its silent behavior can be very confusing. Ideally of course this bug doesn't exist, but I don't think the compiler should just silently be turning catchable errors into uncatchable errors. At the very least a warning should be emitted.