[cfe] Start implementing reachability analysis involving type Never

Change-Id: I80edd4dd1b46b533a4f50243e1d3b18aa00f80ac
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/123250
Commit-Queue: Dmitry Stefantsov <dmitryas@google.com>
Reviewed-by: Paul Berry <paulberry@google.com>
Reviewed-by: Johnni Winther <johnniwinther@google.com>

Author: Dmitry Stefantsov

pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart

@@ -1045,10 +1045,13 @@ class InferenceVisitor
     Expression condition =
         inferrer.ensureAssignableResult(expectedType, conditionResult);
     node.condition = condition..parent = node;
+    inferrer.flowAnalysis.ifStatement_thenBegin(condition);
     inferrer.inferStatement(node.then);
     if (node.otherwise != null) {
+      inferrer.flowAnalysis.ifStatement_elseBegin();
       inferrer.inferStatement(node.otherwise);
     }
+    inferrer.flowAnalysis.ifStatement_end(node.otherwise != null);
   }
 
   ExpressionInferenceResult visitIntJudgment(

pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart

@@ -1452,6 +1452,9 @@ class TypeInferrerImpl implements TypeInferrer {
             messageVoidExpression, expression.fileOffset, noLength);
       }
     }
+    if (result.inferredType is NeverType) {
+      flowAnalysis.handleExit();
+    }
     return result;
   }
 

pkg/front_end/lib/src/testing/id_extractor.dart

@@ -140,6 +140,14 @@ abstract class DataExtractor<T> extends Visitor with DataRegistry<T> {
     return new NodeId(node.fileOffset, IdKind.moveNext);
   }
 
+  NodeId createExpressionStatementId(ExpressionStatement node) {
+    if (node.expression.fileOffset == TreeNode.noOffset) {
+      // TODO(johnniwinther): Find out why we something have no offset.
+      return null;
+    }
+    return new NodeId(node.expression.fileOffset, IdKind.stmt);
+  }
+
   NodeId createLabeledStatementId(LabeledStatement node) =>
       computeDefaultNodeId(node.body);
   NodeId createLoopId(TreeNode node) => computeDefaultNodeId(node);
@@ -272,6 +280,12 @@ abstract class DataExtractor<T> extends Visitor with DataRegistry<T> {
     super.visitVariableSet(node);
   }
 
+  @override
+  visitExpressionStatement(ExpressionStatement node) {
+    computeForNode(node, createExpressionStatementId(node));
+    return super.visitExpressionStatement(node);
+  }
+
   @override
   visitIfStatement(IfStatement node) {
     computeForNode(node, computeDefaultNodeId(node));

pkg/front_end/test/flow_analysis/reachability/data/never_return_type.dart

@@ -162,14 +162,29 @@ Never topLevelFunction() => throw 'foo';
 class C {
   final dynamic field1;
   final dynamic field2;
+
+  /*cfe.member: C.method:doesNotComplete*/
   Never method() => throw 'foo';
+
+  /*cfe.member: C.staticMethod:doesNotComplete*/
   static Never staticMethod() => throw 'foo';
+
   void methodTakingArgument(arg) {}
   void methodTakingNamedArgument({arg}) {}
+
+  /*cfe.member: C.getter:doesNotComplete*/
   Never get getter => throw 'foo';
+
+  /*cfe.member: C.staticGetter:doesNotComplete*/
   static Never get staticGetter => throw 'foo';
+
+  /*cfe.member: C.+:doesNotComplete*/
   Never operator +(other) => throw 'foo';
+
+  /*cfe.member: C.[]:doesNotComplete*/
   Never operator [](other) => throw 'foo';
+
+  /*cfe.member: C.unary-:doesNotComplete*/
   Never operator -() => throw 'foo';
 
   /*member: C.constructor_initializer:doesNotComplete*/

pkg/front_end/test/flow_analysis/reachability/reachability_test.dart

@@ -32,7 +32,6 @@ main(List<String> args) async {
         'assert.dart',
         'do.dart',
         'for.dart',
-        'never_return_type.dart',
         'switch.dart',
         'try_catch.dart',
       ]);
@@ -84,7 +83,14 @@ class ReachabilityDataExtractor
   @override
   Set<_ReachabilityAssertion> computeNodeValue(Id id, TreeNode node) {
     Set<_ReachabilityAssertion> result = {};
-    if (_flowResult.unreachableNodes.contains(node)) {
+    if (node is Expression && node.parent is ExpressionStatement) {
+      // The reachability of an expression statement and the statement it
+      // contains should always be the same.  We check this with an assert
+      // statement, and only annotate the expression statement, to reduce the
+      // amount of redundancy in the test files.
+      assert(_flowResult.unreachableNodes.contains(node) ==
+          _flowResult.unreachableNodes.contains(node.parent));
+    } else if (_flowResult.unreachableNodes.contains(node)) {
       result.add(_ReachabilityAssertion.unreachable);
     }
     if (node is FunctionDeclaration) {

pkg/front_end/test/spell_checking_list_common.txt

@@ -2250,6 +2250,7 @@ redirects
 reduce
 reduced
 reduces
+redundancy
 redundant
 refactor
 refer