[partially defined] implement support for try statements

[ilinum]

This adds support for try/except/finally/else check.

The implementation ended up pretty complicated because it had to handle jumps different for finally. It took me a few iterations to get to this solution and that's the cleanest one I could come up with.

Let me know if you have suggestions on how to structure the code differently.

Closes #13928.

[JukkaL]

Hmm, nested try statements seem to be potentially quite inefficient due to exponential behavior? I'll try to come up with a way to avoid analyzing the same nodes multiple times.

[ilinum]

Hmm, nested try statements seem to be potentially quite inefficient due to exponential behavior? I'll try to come up with a way to avoid analyzing the same nodes multiple times.

So right now we process the body for every except type. We could probably cache the result of processing the body and just reuse that. What do you think about that?

Note that we will still need to process it twice (once with disabling jumps and once without). That one is potentially more difficult to fix.

[ilinum]

This handling is not correct. I think they should be defined conditionally for the handler.

[JukkaL]

Here's a quick idea about how we might be able to avoid exponential behavior. I haven't fully thought this out -- there maybe some obvious thing why this doesn't work. Anyway, I wonder if we could analyze a try/except like these statements (and just once):

  if ...:
      try_body
  if ...:
      except 1
  elif ...:
      except 2
  elif ...:
      except 3
  else:
      else_block
  finally_block

The target try statement would look like this:

try:
    try_body
<except blocks 1..3>
else:
    else_block
finally:
    finally_block

[ilinum]

I implemented your proposal (which was pretty easy). Here's an example where this doesn't work:

def f1(div: int) -> int:
    try:
        x = 100 // div
    except ArithmeticError:
        x = 0
    return x  # False positive: "x" is always defined but we get an error here.

This is happening because the body of the try is conditional, independently of the except clause.

Now, I also implemented the following:

if ...:
   try_body
   else_block
elif ...:  # Note the change from if to elif here.
   except 1
elif ...:
   except 2
finally_block

However, in this case we don't detect undefined variables inside finally itself.

def f0(div: int) -> int:
    try:
        x = 100 // div
    except ArithmeticError:
        return 0
    finally:
        # "x" is not defined in the except ArithmeticError branch, which returns. 
        # Because it returns, the PartiallyDefined check considers this branch "skipped"
        # and doesn't think it's undefined.
        y = x  # False negative: this should be an error but mypy reports nothing. 
    return y

So to implement it 100% correct, we need to disable branch skipping. I have updated this PR with a version of the check that goes through every try/except/finally 2 times (the previous implementation was doing some unnecessary work). I believe this is the best we can do, unless we're willing to trade off correctness.

I've also found an unrelated bug in nested branch statements that get skipped. It's fixed and I added tests.

[JukkaL]

Looks good! Apologies for the slow review.

[JukkaL]

The error codes need to be updated.

[github-actions]

According to mypy_primer, this change has no effect on the checked open source code. 🤖🎉