SE-0413: Typed throws

[Douglas_Gregor]

@xwu

First, regarding this rule—

If a throws-clause is present, then there must be at least one catch-clause.

Why this requirement? Could it not be useful for a non-catching do for the purposes of closure type inference?

A do without a catch doesn't introduce a new context in which the errors can be caught, so the body is still treated as being part of the enclosing context.

@xwu

But suppose we have:

func callCat() throws(CatError) -> Cat {
  do throws(DogError) {
    throw .sleeps  // (1)
  } catch {
    throw .sleeps  // (2)
  }
  fatalError()
}

Am I correct in deducing that DogError.sleeps is thrown at (1), which is caught as an error of static type DogError and handled by rethrowing CatError.sleeps at (2)?

Yes, that is correct. The key consideration here is that the body of the do..catch statement in which the throws clause is relevant is what's in the {...} immediately following the do. The bodies of catch clauses are in the throwing context of whatever the do...catch is embedded in, which is the function itself in all of your examples.

@xwu

throws-clause not being part of this amendment (and hence not in the diff), I'm assuming this permits:

do throws /* note: no type */ { ... } catch { ... }

Yes. throws-clause is defined as:

throws-clause -> throws thrown-type(opt)

so do throws is permitted.

@xwu

If so, does this "force box" the error—i.e., is it equivalent to do throws(any Error)...—or is it always equivalent to bare do { ... } catch { ... }?

This force-boxes the error thrown from the do body to any Error. throws is equivalent to throws(any Error) in other contexts, and that should remain true here.

@xwu

Can you explain how the following behaves?

func j() throws {
  do throws(F) {
    throw .e // throws error of type `F`
  } catch {
    throw .e // throws error of type `E` (I think?)
  }
}

Yes, you are correct. That extension Error where Self == E did, in fact, make my life more difficult. I'll be turning that into a compiler test case...

@xwu

func k() throws(F) {
  do throws(E) {
    throw .e // (5)
  } catch is E {
    throw .e // (6)
  }
  // ...
}

(5) throws E.e, (6) throws F.e.

@xwu

func l() throws(F) {
  do throws {
    throw .e // (7)
  } catch is E {
    throw .e // (8)
  }
  // ...
}

(7) throws E.e via your evil extension, (8) throws F.e.

@xwu

func m() throws(F) {
  do throws(any Error) {
    throw .e // (9)
  } catch is E {
    throw .e // (10)
  }
  // ...
}

(9) throws E.e via your evil extension, (10) throws F.e.

@xwu

func n() throws(F) {
  do {
    throw .e // (11)
  } catch is E {
    throw .e // (12)
  }
  // ...
}

(11) throws E.e via your evil extension, (12) throws F.e.

Doug