[analyzer] Dot shorthands: Add DotShorthandMixin to PostfixExpression to handle null-assert expressions.

The parser now handles the `!` operator which wouldn't be captured originally because we are parsing the shorthand with SELECTOR_PRECEDENCE.

Added a language test since no tests currently cover the usage of `!` and a few unit tests.

Bug: #59835
Change-Id: I66bdcc9a083c98d91b16d3ce8c952b8d4010ecd9
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/425155
Reviewed-by: Jens Johansen <[email protected]>
Commit-Queue: Kallen Tu <[email protected]>

Author: kallentu

pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart

@@ -5878,6 +5878,15 @@ class Parser {
           typeArg, token, constantPatternContext,
           isDotShorthand: true);
 
+      // With SELECTOR_PRECEDENCE, the `!` operator isn't parsed before
+      // handling the dot shorthand context. We want to capture and handle the
+      // null-assert before caching the context type.
+      Token next = token.next!;
+      if (next.isA(TokenType.BANG)) {
+        listener.handleNonNullAssertExpression(next);
+        token = next;
+      }
+
       // The entire shorthand is parsed at this point.
       listener.handleDotShorthandContext(dot);
     }

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

@@ -15530,7 +15530,10 @@ abstract final class PostfixExpression
 }
 
 final class PostfixExpressionImpl extends ExpressionImpl
-    with NullShortableExpressionImpl, CompoundAssignmentExpressionImpl
+    with
+        NullShortableExpressionImpl,
+        CompoundAssignmentExpressionImpl,
+        DotShorthandMixin
     implements PostfixExpression {
   ExpressionImpl _operand;
 

pkg/analyzer/lib/src/generated/resolver.dart

@@ -3621,19 +3621,27 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
 
   @override
   void visitPostfixExpression(
-    PostfixExpression node, {
+    covariant PostfixExpressionImpl node, {
     TypeImpl contextType = UnknownInferredType.instance,
   }) {
     inferenceLogWriter?.enterExpression(node, contextType);
+
+    // If [isDotShorthand] is set, cache the context type for resolution.
+    if (isDotShorthand(node)) {
+      pushDotShorthandContext(node, SharedTypeSchemaView(contextType));
+    }
+
     checkUnreachableNode(node);
-    _postfixExpressionResolver.resolve(
-      node as PostfixExpressionImpl,
-      contextType: contextType,
-    );
+    _postfixExpressionResolver.resolve(node, contextType: contextType);
     _insertImplicitCallReference(
       insertGenericFunctionInstantiation(node, contextType: contextType),
       contextType: contextType,
     );
+
+    if (isDotShorthand(node)) {
+      popDotShorthandContext();
+    }
+
     inferenceLogWriter?.exitExpression(node);
   }
 

pkg/analyzer/test/src/dart/resolution/dot_shorthand_property_access_test.dart

@@ -296,6 +296,57 @@ DotShorthandPropertyAccess
 ''');
   }
 
+  test_equality_nullAssert() async {
+    await assertNoErrorsInCode(r'''
+class C {
+  int x;
+  C(this.x);
+  static C? nullable = C(1);
+}
+
+main() {
+  print(C(1) == .nullable!);
+}
+''');
+
+    var identifier = findNode.singleDotShorthandPropertyAccess;
+    assertResolvedNodeText(identifier, r'''
+DotShorthandPropertyAccess
+  period: .
+  propertyName: SimpleIdentifier
+    token: nullable
+    element: <testLibraryFragment>::@class::C::@getter::nullable#element
+    staticType: C?
+  staticType: C?
+''');
+  }
+
+  test_equality_nullAssert_chain() async {
+    await assertNoErrorsInCode(r'''
+class C {
+  int x;
+  C(this.x);
+  static C? nullable = C(1);
+  C? member = C(1);
+}
+
+main() {
+  print(C(1) == .nullable!.member!);
+}
+''');
+
+    var identifier = findNode.singleDotShorthandPropertyAccess;
+    assertResolvedNodeText(identifier, r'''
+DotShorthandPropertyAccess
+  period: .
+  propertyName: SimpleIdentifier
+    token: nullable
+    element: <testLibraryFragment>::@class::C::@getter::nullable#element
+    staticType: C?
+  staticType: C?
+''');
+  }
+
   test_equality_pattern() async {
     await assertNoErrorsInCode('''
 enum Color { red, blue }

tests/language/dot_shorthands/multiple/null_assert_test.dart

@@ -0,0 +1,26 @@
+// Copyright (c) 2025, 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.
+
+// Tests for the postfix null assert operator `!`.
+
+// SharedOptions=--enable-experiment=dot-shorthands
+
+import "package:expect/expect.dart";
+
+class C {
+  int x;
+  C(this.x);
+  static C? nullable = C(1);
+  C? member() => C(1);
+}
+
+main() {
+  C nullAssert = .nullable!;
+  Expect.equals(1, nullAssert.x);
+
+  C nullAssertChain = .nullable!.member()!;
+  Expect.equals(1, nullAssertChain.x);
+
+  bool nullAssertEq = C(1) == .nullable!.member()!;
+}