Fix crash when a null shorting expression is null checked.

Postfix increments and decrements are null-shorting expressions
(e.g. `x?.y++.isEven` only calls `isEven` if `x` was non-null), but it
is still being decided whether postfix `!` should be null shorting
(i.e. whether `x?.y!` should fail if `x` is null).  See
dart-lang/language#1163.

Previously, the analyzer was inconsistent about whether it considered
`!` to participate in null shorting; as a result, when analyzing an
expression like `x?.y!`, the analyzer would fail to call
`FlowAnalysis.nullAwareAccess_end`, resulting in corrupted flow
analysis state, which could lead to a crash.

This change makes the analyzer treat `!` as *not* participating in
null shorting, which is consistent with what is currently written in
the spec and implemented in the CFE.

Fixes #43093.

Change-Id: Ie69c5c29f226fe1a0282d0e7a1e079778dc700c3
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/159147
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: stereotype441

pkg/analyzer/lib/src/dart/ast/ast.dart

@@ -8078,7 +8078,8 @@ class PostfixExpressionImpl extends ExpressionImpl
   }
 
   @override
-  bool _extendsNullShorting(Expression child) => identical(child, operand);
+  bool _extendsNullShorting(Expression child) =>
+      operator.type != TokenType.BANG && identical(child, operand);
 }
 
 /// An identifier that is prefixed or an access to an object property where the

tests/language/nnbd/flow_analysis/issue43093_test.dart

@@ -0,0 +1,34 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// This is a regression test for a bug in which `!` applied to a null-shorting
+// expression would corrupt the state of flow analysis, causing a crash when
+// trying to finish analyzing an enclosing `if` statement.
+
+// SharedOptions=--enable-experiment=non-nullable
+import 'package:expect/expect.dart';
+
+class C {
+  final int? x;
+  C(this.x);
+}
+
+int? f(bool b, C? c) {
+  if (b) {
+    return c?.x!;
+  } else {
+    return null;
+  }
+}
+
+main() {
+  // Note: it is currently being discussed whether `!` should participate in
+  // null shorting (see https://github.com/dart-lang/language/issues/1163), so
+  // let's not have an expectation about whether `f(true, null)` should throw an
+  // exception.
+  //  f(true, null);
+
+  Expect.throws(() => f(true, C(null)));
+  Expect.equals(f(true, C(1)), 1);
+}