Support for null-aware ExtensionOverride.

Bug: #41780
Change-Id: Ib5d11000847434c679df1ec882ee6d9777670fe0
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/151097
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

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

@@ -2106,6 +2106,9 @@ abstract class ExtensionOverride implements Expression {
   /// Return the name of the extension being selected.
   Identifier get extensionName;
 
+  /// Whether this override is null aware (as opposed to non-null).
+  bool get isNullAware;
+
   /// Return the forced extension element.
   ///
   /// Return `null` if the AST structure has not been resolved.

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

@@ -3925,6 +3925,13 @@ class ExtensionOverrideImpl extends ExpressionImpl
     _extensionName = _becomeParentOf(extensionName as IdentifierImpl);
   }
 
+  @override
+  bool get isNullAware {
+    var nextType = argumentList.endToken.next.type;
+    return nextType == TokenType.QUESTION_PERIOD ||
+        nextType == TokenType.QUESTION_PERIOD_OPEN_SQUARE_BRACKET;
+  }
+
   @override
   Precedence get precedence => Precedence.postfix;
 

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

@@ -136,6 +136,10 @@ class ExtensionMemberResolver {
     var receiverExpression = arguments[0];
     var receiverType = receiverExpression.staticType;
 
+    if (node.isNullAware) {
+      receiverType = _typeSystem.promoteToNonNull(receiverType);
+    }
+
     var typeArgumentTypes = _inferTypeArguments(node, receiverType);
     nodeImpl.typeArgumentTypes = typeArgumentTypes;
 

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

@@ -412,7 +412,11 @@ class ElementResolver extends SimpleAstVisitor<void> {
     }
 
     if (node.isNullAware) {
-      targetType = _typeSystem.promoteToNonNull(targetType);
+      if (target is ExtensionOverride) {
+        // https://github.com/dart-lang/language/pull/953
+      } else {
+        targetType = _typeSystem.promoteToNonNull(targetType);
+      }
     }
 
     String getterMethodName = TokenType.INDEX.lexeme;

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

@@ -847,10 +847,13 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
   void visitIndexExpression(IndexExpression node) {
     _checkForArgumentTypeNotAssignableForArgument(node.index);
     if (node.isNullAware) {
-      _checkForUnnecessaryNullAware(
-        node.realTarget,
-        node.question ?? node.period ?? node.leftBracket,
-      );
+      var target = node.realTarget;
+      if (_isExpressionWithType(target)) {
+        _checkForUnnecessaryNullAware(
+          target,
+          node.question ?? node.period ?? node.leftBracket,
+        );
+      }
     }
     super.visitIndexExpression(node);
   }
@@ -944,9 +947,7 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
       _checkForStaticAccessToInstanceMember(typeReference, methodName);
       _checkForInstanceAccessToStaticMember(
           typeReference, node.target, methodName);
-
-      // For `C?.foo()` the type of `C` is not set, it is not an expression.
-      if (target.staticType != null) {
+      if (_isExpressionWithType(target)) {
         _checkForUnnecessaryNullAware(target, node.operator);
       }
     } else {
@@ -1051,9 +1052,7 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
     _checkForStaticAccessToInstanceMember(typeReference, propertyName);
     _checkForInstanceAccessToStaticMember(
         typeReference, node.target, propertyName);
-
-    // For `C?.x` the type of `C` is not set, because it is not an expression.
-    if (target.staticType != null) {
+    if (_isExpressionWithType(target)) {
       _checkForUnnecessaryNullAware(target, node.operator);
     }
 
@@ -5390,6 +5389,22 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
     }
     return null;
   }
+
+  static bool _isExpressionWithType(Expression node) {
+    if (node is ExtensionOverride) {
+      return false;
+    }
+
+    // For `C?.foo()` the type of `C` is not set, it is not an expression.
+    if (node is Identifier) {
+      var element = node.staticElement;
+      if (element is ClassElement || element is ExtensionElement) {
+        return false;
+      }
+    }
+
+    return true;
+  }
 }
 
 /**

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

@@ -10,11 +10,13 @@ import 'package:meta/meta.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
+import '../constant/potentially_constant_test.dart';
 import 'driver_resolution.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(ExtensionOverrideTest);
+    defineReflectiveTests(ExtensionOverrideWithNullSafetyTest);
   });
 }
 
@@ -311,20 +313,20 @@ void f(A a) {
     validateBinaryExpression();
   }
 
-  test_operator_onTearoff() async {
+  test_operator_onTearOff() async {
     // https://github.com/dart-lang/sdk/issues/38653
     await assertErrorsInCode('''
-f(){
-  E(null).v++;
-}
-extension E on Object{
+extension E on int {
   v() {}
 }
+
+f(){
+  E(0).v++;
+}
 ''', [
-      error(CompileTimeErrorCode.UNDEFINED_EXTENSION_SETTER, 15, 1),
+      error(CompileTimeErrorCode.UNDEFINED_EXTENSION_SETTER, 45, 1),
     ]);
-    findDeclarationAndOverride(
-        declarationName: 'E ', overrideSearch: 'E(null)');
+    findDeclarationAndOverride(declarationName: 'E ', overrideSearch: 'E(0)');
     validateOverride();
   }
 
@@ -518,7 +520,7 @@ void f(p.A a) {
     validatePropertyAccess();
   }
 
-  test_tearoff() async {
+  test_tearOff() async {
     await assertNoErrorsInCode('''
 class C {}
 
@@ -601,3 +603,95 @@ f(C c) => E(c).a;
     expect(resolvedElement, expectedElement);
   }
 }
+
+@reflectiveTest
+class ExtensionOverrideWithNullSafetyTest extends ExtensionOverrideTest
+    with WithNullSafetyMixin {
+  test_indexExpression_read_nullAware() async {
+    await assertNoErrorsInCode('''
+extension E on int {
+  int operator [](int index) => 0;
+}
+
+void f(int? a) {
+  E(a)?.[0];
+}
+''');
+
+    assertIndexExpression(
+      findNode.index('[0]'),
+      readElement: findElement.method('[]', of: 'E'),
+      writeElement: null,
+      type: 'int?',
+    );
+  }
+
+  test_indexExpression_write_nullAware() async {
+    await assertNoErrorsInCode('''
+extension E on int {
+  operator []=(int index, int value) {}
+}
+
+void f(int? a) {
+  E(a)?.[0] = 1;
+}
+''');
+
+    assertIndexExpression(
+      findNode.index('[0]'),
+      readElement: null,
+      writeElement: findElement.method('[]=', of: 'E'),
+      type: 'int?',
+    );
+  }
+
+  test_methodInvocation_nullAware() async {
+    await assertNoErrorsInCode('''
+extension E on int {
+  int foo() => 0;
+}
+
+void f(int? a) {
+  E(a)?.foo();
+}
+''');
+
+    assertMethodInvocation2(
+      findNode.methodInvocation('foo();'),
+      element: findElement.method('foo'),
+      typeArgumentTypes: [],
+      invokeType: 'int Function()',
+      type: 'int?',
+    );
+  }
+
+  test_propertyAccess_getter_nullAware() async {
+    await assertNoErrorsInCode('''
+extension E on int {
+  int get foo => 0;
+}
+
+void f(int? a) {
+  E(a)?.foo;
+}
+''');
+
+    assertPropertyAccess2(
+      findNode.propertyAccess('?.foo'),
+      element: findElement.getter('foo'),
+      type: 'int?',
+    );
+  }
+
+  test_propertyAccess_setter_nullAware() async {
+    await assertNoErrorsInCode('''
+extension E on int {
+  set foo(int _) {}
+}
+
+void f(int? a) {
+  E(a)?.foo = 0;
+}
+''');
+  }
+}