Migration: integrate flow analysis of try/catch/finally statements.

Change-Id: I2e826fc28c8acc5abae23e318cc21ec8053251a8
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/114552
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: stereotype441

pkg/nnbd_migration/lib/src/edge_builder.dart

@@ -391,6 +391,7 @@ class EdgeBuilder extends GeneralizingAstVisitor<DecoratedType>
 
   @override
   DecoratedType visitCatchClause(CatchClause node) {
+    _flowAnalysis.tryCatchStatement_catchBegin();
     node.exceptionType?.accept(this);
     for (var identifier in [
       node.exceptionParameter,
@@ -404,6 +405,7 @@ class EdgeBuilder extends GeneralizingAstVisitor<DecoratedType>
     // The catch clause may not execute, so create a new scope for
     // post-dominators.
     _postDominatedLocals.doScoped(action: () => node.body.accept(this));
+    _flowAnalysis.tryCatchStatement_catchEnd();
     return null;
   }
 
@@ -1134,6 +1136,32 @@ class EdgeBuilder extends GeneralizingAstVisitor<DecoratedType>
     return null;
   }
 
+  @override
+  DecoratedType visitTryStatement(TryStatement node) {
+    var finallyBlock = node.finallyBlock;
+    if (finallyBlock != null) {
+      _flowAnalysis.tryFinallyStatement_bodyBegin();
+    }
+    var catchClauses = node.catchClauses;
+    if (catchClauses.isNotEmpty) {
+      _flowAnalysis.tryCatchStatement_bodyBegin();
+    }
+    var body = node.body;
+    body.accept(this);
+    var assignedInBody = _assignedVariables[body];
+    if (catchClauses.isNotEmpty) {
+      _flowAnalysis.tryCatchStatement_bodyEnd(assignedInBody);
+      catchClauses.accept(this);
+      _flowAnalysis.tryCatchStatement_end();
+    }
+    if (finallyBlock != null) {
+      _flowAnalysis.tryFinallyStatement_finallyBegin(assignedInBody);
+      finallyBlock.accept(this);
+      _flowAnalysis.tryFinallyStatement_end(_assignedVariables[finallyBlock]);
+    }
+    return null;
+  }
+
   @override
   DecoratedType visitTypeName(TypeName typeName) {
     var typeArguments = typeName.typeArguments?.arguments;

pkg/nnbd_migration/test/edge_builder_flow_analysis_test.dart

@@ -230,6 +230,78 @@ void h(int k) {}
     assertEdge(iNode, jNode, hard: false);
   }
 
+  test_catch_cancels_promotions_based_on_assignments_in_body() async {
+    await analyze('''
+void f(int i) {
+  if (i == null) return;
+  try {
+    g(i);
+    i = null;
+    if (i == null) return;
+    g(i);
+  } catch (_) {
+    h(i);
+  }
+}
+void g(int j) {}
+void h(int k) {}
+''');
+    var iNode = decoratedTypeAnnotation('int i').node;
+    var jNode = decoratedTypeAnnotation('int j').node;
+    var kNode = decoratedTypeAnnotation('int k').node;
+    // No edge from i to j because i is promoted at the time of both calls to g.
+    assertNoEdge(iNode, jNode);
+    // But there is an edge from i to k, because there is no guarantee that i is
+    // promoted at all times during the execution of the try block.
+    assertEdge(iNode, kNode, hard: false);
+  }
+
+  test_catch_falls_through_to_after_try() async {
+    await analyze('''
+void f(int i) {
+  try {
+    g(i);
+    return;
+  } catch (_) {
+    if (i == null) return;
+  }
+  h(i);
+}
+void g(int j) {}
+void h(int k) {}
+''');
+    var iNode = decoratedTypeAnnotation('int i').node;
+    var jNode = decoratedTypeAnnotation('int j').node;
+    var kNode = decoratedTypeAnnotation('int k').node;
+    // No edge from i to k because i's type is promoted to non-nullable
+    assertNoEdge(iNode, kNode);
+    // But there is an edge from i to j.
+    assertEdge(iNode, jNode, hard: true);
+  }
+
+  test_catch_resets_to_state_before_try() async {
+    await analyze('''
+void f(int i) {
+  try {
+    if (i == null) return;
+    g(i);
+  } catch (_) {
+    h(i);
+  }
+}
+void g(int j) {}
+void h(int k) {}
+''');
+    var iNode = decoratedTypeAnnotation('int i').node;
+    var jNode = decoratedTypeAnnotation('int j').node;
+    var kNode = decoratedTypeAnnotation('int k').node;
+    // No edge from i to j because i's type is promoted to non-nullable
+    assertNoEdge(iNode, jNode);
+    // But there is an edge from i to k, since we assume an exception might
+    // occur at any time during the body of the try.
+    assertEdge(iNode, kNode, hard: false);
+  }
+
   test_conditionalExpression() async {
     await analyze('''
 int f(int i) => i == null ? g(i) : h(i);
@@ -455,6 +527,53 @@ class C {
     // field doesn't cause flow analysis to crash.
   }
 
+  test_finally_promotions_are_preserved() async {
+    await analyze('''
+void f(int i) {
+  try {
+    g(i);
+  } finally {
+    if (i == null) return;
+  }
+  h(i);
+}
+void g(int j) {}
+void h(int k) {}
+''');
+    var iNode = decoratedTypeAnnotation('int i').node;
+    var jNode = decoratedTypeAnnotation('int j').node;
+    var kNode = decoratedTypeAnnotation('int k').node;
+    // No edge from i to k because i's type is promoted to non-nullable in the
+    // finally block.
+    assertNoEdge(iNode, kNode);
+    // But there is an edge from i to j.
+    assertEdge(iNode, jNode, hard: true);
+  }
+
+  test_finally_temporarily_resets_to_state_before_try() async {
+    await analyze('''
+void f(int i) {
+  try {
+    if (i == null) return;
+    g(i);
+  } finally {
+    h(i);
+  }
+}
+void g(int j) {}
+void h(int k) {}
+''');
+    var iNode = decoratedTypeAnnotation('int i').node;
+    var jNode = decoratedTypeAnnotation('int j').node;
+    var kNode = decoratedTypeAnnotation('int k').node;
+    // No edge from i to j because i's type is promoted to non-nullable in the
+    // try-block.
+    assertNoEdge(iNode, jNode);
+    // But there is an edge from i to k, since we assume an exception might
+    // occur at any time during the body of the try.
+    assertEdge(iNode, kNode, hard: false);
+  }
+
   test_for_break_target() async {
     await analyze('''
 void f(int i) {
@@ -995,6 +1114,29 @@ bool b3 = b1 || b2;
     // top level variable doesn't cause flow analysis to crash.
   }
 
+  test_try_falls_through_to_after_try() async {
+    await analyze('''
+void f(int i) {
+  try {
+    g(i);
+    if (i == null) return;
+  } catch (_) {
+    return;
+  }
+  h(i);
+}
+void g(int j) {}
+void h(int k) {}
+''');
+    var iNode = decoratedTypeAnnotation('int i').node;
+    var jNode = decoratedTypeAnnotation('int j').node;
+    var kNode = decoratedTypeAnnotation('int k').node;
+    // No edge from i to k because i's type is promoted to non-nullable
+    assertNoEdge(iNode, kNode);
+    // But there is an edge from i to j.
+    assertEdge(iNode, jNode, hard: true);
+  }
+
   test_while_break_target() async {
     await analyze('''
 void f(int i) {