Completion. Issue 35449. Don't suggest @Protected instance members when not available.

Bug: #35449
Change-Id: Ie8d0b3ba354addbf42d2a4efe9c4dbf318e6c659
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/358120
Reviewed-by: Keerti Parthasarathy <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analysis_server/lib/src/services/completion/dart/declaration_helper.dart

@@ -662,10 +662,9 @@ class DeclarationHelper {
         ? request.inheritanceManager.getInheritedConcreteMap2(type.element)
         : request.inheritanceManager.getInterface(type.element).map;
 
-    var library = request.libraryElement;
     var membersByName = <String, List<ExecutableElement>>{};
     for (var rawMember in map.values) {
-      if (!rawMember.isStatic && rawMember.isAccessibleIn(library)) {
+      if (_canAccessInstanceMember(rawMember)) {
         var name = rawMember.displayName;
         membersByName
             .putIfAbsent(name, () => <ExecutableElement>[])
@@ -1020,6 +1019,38 @@ class DeclarationHelper {
     }
   }
 
+  bool _canAccessInstanceMember(ExecutableElement element) {
+    if (element.isStatic) {
+      return false;
+    }
+
+    var requestLibrary = request.libraryElement;
+    if (!element.isAccessibleIn(requestLibrary)) {
+      return false;
+    }
+
+    if (element.isProtected) {
+      var elementInterface = element.enclosingElement;
+      if (elementInterface is! InterfaceElement) {
+        return false;
+      }
+
+      if (elementInterface.library != requestLibrary) {
+        var contextInterface = request.target.enclosingInterfaceElement;
+        if (contextInterface == null) {
+          return false;
+        }
+
+        var contextType = contextInterface.thisType;
+        if (contextType.asInstanceOf(elementInterface) == null) {
+          return false;
+        }
+      }
+    }
+
+    return true;
+  }
+
   /// Returns `true` if the [identifier] is composed of one or more underscore
   /// characters and nothing else.
   bool _isUnused(String identifier) => UnusedIdentifier.hasMatch(identifier);
@@ -1695,3 +1726,25 @@ extension on PropertyAccessorElement {
     return false;
   }
 }
+
+extension on ExecutableElement {
+  bool get isProtected {
+    final self = this;
+    if (self is PropertyAccessorElement &&
+        self.enclosingElement is InterfaceElement) {
+      if (self.hasProtected) {
+        return true;
+      }
+      var variable = self.variable2;
+      if (variable != null && variable.hasProtected) {
+        return true;
+      }
+    }
+    if (self is MethodElement &&
+        self.enclosingElement is InterfaceElement &&
+        self.hasProtected) {
+      return true;
+    }
+    return false;
+  }
+}

pkg/analysis_server/test/services/completion/dart/location/property_access_expression_test.dart

@@ -171,6 +171,314 @@ class A { foo() {int x; x.^}}
 ''');
     assertResponse(r'''
 suggestions
+''');
+  }
+
+  Future<void> test_isProtected_field_otherLibrary_function() async {
+    writeTestPackageConfig(
+      meta: true,
+    );
+
+    newFile('$testPackageLibPath/a.dart', r'''
+import 'package:meta/meta.dart';
+
+class A {
+  int f01 = 0;
+
+  @protected
+  int f02 = 0;
+}
+''');
+
+    await computeSuggestions('''
+import 'a.dart';
+
+void f(A a) {
+  a.^
+}
+''');
+
+    assertResponse(r'''
+suggestions
+  f01
+    kind: field
+''');
+  }
+
+  Future<void> test_isProtected_field_sameLibrary_function() async {
+    writeTestPackageConfig(
+      meta: true,
+    );
+
+    await computeSuggestions('''
+import 'package:meta/meta.dart';
+
+class A {
+  int f01 = 0;
+
+  @protected
+  int f02 = 0;
+}
+
+void f(A a) {
+  a.^
+}
+''');
+
+    assertResponse(r'''
+suggestions
+  f01
+    kind: field
+  f02
+    kind: field
+''');
+  }
+
+  Future<void> test_isProtected_getter_otherLibrary_function() async {
+    writeTestPackageConfig(
+      meta: true,
+    );
+
+    newFile('$testPackageLibPath/a.dart', r'''
+import 'package:meta/meta.dart';
+
+class A {
+  int get f01 => 0;
+
+  @protected
+  int get f02 => 0;
+}
+''');
+
+    await computeSuggestions('''
+import 'a.dart';
+
+void f(A a) {
+  a.^
+}
+''');
+
+    assertResponse(r'''
+suggestions
+  f01
+    kind: getter
+''');
+  }
+
+  Future<void> test_isProtected_getter_sameLibrary_function() async {
+    writeTestPackageConfig(
+      meta: true,
+    );
+
+    await computeSuggestions('''
+import 'package:meta/meta.dart';
+
+class A {
+  int get f01 => 0;
+
+  @protected
+  int get f02 => 0;
+}
+
+void f(A a) {
+  a.^
+}
+''');
+
+    assertResponse(r'''
+suggestions
+  f01
+    kind: getter
+  f02
+    kind: getter
+''');
+  }
+
+  Future<void> test_isProtected_method_otherLibrary_class_notSubtype() async {
+    writeTestPackageConfig(
+      meta: true,
+    );
+
+    newFile('$testPackageLibPath/a.dart', r'''
+import 'package:meta/meta.dart';
+
+class A {
+  void f01() {}
+
+  @protected
+  void f02() {}
+}
+''');
+
+    await computeSuggestions('''
+import 'a.dart';
+
+class B {
+  void foo(A a) {
+    a.^
+  }
+}
+''');
+
+    assertResponse(r'''
+suggestions
+  f01
+    kind: methodInvocation
+''');
+  }
+
+  Future<void> test_isProtected_method_otherLibrary_class_subtype() async {
+    writeTestPackageConfig(
+      meta: true,
+    );
+
+    newFile('$testPackageLibPath/a.dart', r'''
+import 'package:meta/meta.dart';
+
+class A {
+  void f01() {}
+
+  @protected
+  void f02() {}
+}
+''');
+
+    await computeSuggestions('''
+import 'a.dart';
+
+class B extends A {
+  void foo() {
+    this.^
+  }
+}
+''');
+
+    assertResponse(r'''
+suggestions
+  f01
+    kind: methodInvocation
+  f02
+    kind: methodInvocation
+''');
+  }
+
+  Future<void> test_isProtected_method_otherLibrary_function() async {
+    writeTestPackageConfig(
+      meta: true,
+    );
+
+    newFile('$testPackageLibPath/a.dart', r'''
+import 'package:meta/meta.dart';
+
+class A {
+  void f01() {}
+
+  @protected
+  void f02() {}
+}
+''');
+
+    await computeSuggestions('''
+import 'a.dart';
+
+void f(A a) {
+  a.^
+}
+''');
+
+    assertResponse(r'''
+suggestions
+  f01
+    kind: methodInvocation
+''');
+  }
+
+  Future<void> test_isProtected_method_sameLibrary_function() async {
+    writeTestPackageConfig(
+      meta: true,
+    );
+
+    await computeSuggestions('''
+import 'package:meta/meta.dart';
+
+class A {
+  void f01() {}
+
+  @protected
+  void f02() {}
+}
+
+void f(A a) {
+  a.^
+}
+''');
+
+    assertResponse(r'''
+suggestions
+  f01
+    kind: methodInvocation
+  f02
+    kind: methodInvocation
+''');
+  }
+
+  Future<void> test_isProtected_setter_otherLibrary_function() async {
+    writeTestPackageConfig(
+      meta: true,
+    );
+
+    newFile('$testPackageLibPath/a.dart', r'''
+import 'package:meta/meta.dart';
+
+class A {
+  set f01(int _) {}
+
+  @protected
+  set f02(int _) {}
+}
+''');
+
+    await computeSuggestions('''
+import 'a.dart';
+
+void f(A a) {
+  a.^
+}
+''');
+
+    assertResponse(r'''
+suggestions
+  f01
+    kind: setter
+''');
+  }
+
+  Future<void> test_isProtected_setter_sameLibrary_function() async {
+    writeTestPackageConfig(
+      meta: true,
+    );
+
+    await computeSuggestions('''
+import 'package:meta/meta.dart';
+
+class A {
+  set f01(int _) {}
+
+  @protected
+  set f02(int _) {}
+}
+
+void f(A a) {
+  a.^
+}
+''');
+
+    assertResponse(r'''
+suggestions
+  f01
+    kind: setter
+  f02
+    kind: setter
 ''');
   }
 }