analyzer: Support comment references of members of aliased type

Work towards #56109
(specifically support for
#56109 (comment)).

Currently, instance (and static) members of a type can be referenced in
a comment reference. This change adds support to referencing instance
(and static) members of a type via a type alias.

Change-Id: Ic789a0185cb8c56236346ef3ae658481fbd4cd70
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/429226
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Samuel Rawlins <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>

Author: srawlins

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

@@ -65,6 +65,11 @@ class CommentReferenceResolver {
 
     var name = expression.identifier;
 
+    if (prefixElement is TypeAliasElement) {
+      // When resolving `name`, use the aliased element.
+      prefixElement = prefixElement.aliasedType.element3;
+    }
+
     if (prefixElement is PrefixElement) {
       var prefixScope = prefixElement.scope;
       var lookupResult = prefixScope.lookup(name.name);
@@ -132,6 +137,12 @@ class CommentReferenceResolver {
     name.element = element;
 
     var propertyName = expression.propertyName;
+
+    if (element is TypeAliasElement) {
+      // When resolving `propertyName`, use the aliased element.
+      element = element.aliasedType.element3;
+    }
+
     if (element is InterfaceElement) {
       propertyName.element =
           element.getMethod(propertyName.name) ??

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

@@ -102,6 +102,34 @@ CommentReference
 ''');
   }
 
+  test_class_instanceGetter_onTypedef() async {
+    await assertNoErrorsInCode('''
+class A {
+  int get foo => 0;
+}
+typedef B = A;
+
+/// [B.foo]
+void f() {}
+''');
+
+    assertResolvedNodeText(findNode.commentReference('B.foo]'), r'''
+CommentReference
+  expression: PrefixedIdentifier
+    prefix: SimpleIdentifier
+      token: B
+      element: <testLibrary>::@typeAlias::B
+      staticType: null
+    period: .
+    identifier: SimpleIdentifier
+      token: foo
+      element: <testLibraryFragment>::@class::A::@getter::foo#element
+      staticType: null
+    element: <testLibraryFragment>::@class::A::@getter::foo#element
+    staticType: null
+''');
+  }
+
   test_class_instanceMethod() async {
     await assertNoErrorsInCode('''
 class A {
@@ -221,6 +249,35 @@ CommentReference
 ''');
   }
 
+  test_class_staticGetter_onTypedef() async {
+    await assertNoErrorsInCode('''
+class A {
+  static int get foo => 0;
+}
+
+typedef B = A;
+
+/// [B.foo]
+void f() {}
+''');
+
+    assertResolvedNodeText(findNode.commentReference('B.foo]'), r'''
+CommentReference
+  expression: PrefixedIdentifier
+    prefix: SimpleIdentifier
+      token: B
+      element: <testLibrary>::@typeAlias::B
+      staticType: null
+    period: .
+    identifier: SimpleIdentifier
+      token: foo
+      element: <testLibraryFragment>::@class::A::@getter::foo#element
+      staticType: null
+    element: <testLibraryFragment>::@class::A::@getter::foo#element
+    staticType: null
+''');
+  }
+
   test_class_staticMethod() async {
     await assertNoErrorsInCode('''
 class A {
@@ -949,6 +1006,42 @@ CommentReference
 ''');
   }
 
+  test_class_instanceGetter_onTypedef() async {
+    await assertNoErrorsInCode('''
+import '' as self;
+class A {
+  int get foo => 0;
+}
+typedef B = A;
+
+/// [self.B.foo]
+void f() {}
+''');
+
+    assertResolvedNodeText(findNode.commentReference('B.foo]'), r'''
+CommentReference
+  expression: PropertyAccess
+    target: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: self
+        element: <testLibraryFragment>::@prefix2::self
+        staticType: null
+      period: .
+      identifier: SimpleIdentifier
+        token: B
+        element: <testLibrary>::@typeAlias::B
+        staticType: null
+      element: <testLibrary>::@typeAlias::B
+      staticType: null
+    operator: .
+    propertyName: SimpleIdentifier
+      token: foo
+      element: <testLibraryFragment>::@class::A::@getter::foo#element
+      staticType: null
+    staticType: null
+''');
+  }
+
   test_class_instanceMethod() async {
     await assertNoErrorsInCode('''
 import '' as self;
@@ -1054,6 +1147,42 @@ CommentReference
 ''');
   }
 
+  test_class_staticGetter_onTypedef() async {
+    await assertNoErrorsInCode('''
+import '' as self;
+class A {
+  static int get foo => 0;
+}
+typedef B = A;
+
+/// [self.B.foo]
+void f() {}
+''');
+
+    assertResolvedNodeText(findNode.commentReference('B.foo]'), r'''
+CommentReference
+  expression: PropertyAccess
+    target: PrefixedIdentifier
+      prefix: SimpleIdentifier
+        token: self
+        element: <testLibraryFragment>::@prefix2::self
+        staticType: null
+      period: .
+      identifier: SimpleIdentifier
+        token: B
+        element: <testLibrary>::@typeAlias::B
+        staticType: null
+      element: <testLibrary>::@typeAlias::B
+      staticType: null
+    operator: .
+    propertyName: SimpleIdentifier
+      token: foo
+      element: <testLibraryFragment>::@class::A::@getter::foo#element
+      staticType: null
+    staticType: null
+''');
+  }
+
   test_class_staticMethod() async {
     await assertNoErrorsInCode('''
 import '' as self;

pkg/linter/test/rules/comment_references_test.dart

@@ -17,13 +17,6 @@ class CommentReferencesTest extends LintRuleTest {
   @override
   String get lintRule => LintNames.comment_references;
 
-  test_constructorTearoff() async {
-    await assertNoDiagnostics(r'''
-/// Text [Future.delayed].
-class C {}
-''');
-  }
-
   test_false() async {
     await assertDiagnostics(
       r'''
@@ -184,6 +177,13 @@ class B extends A {
 ''');
   }
 
+  test_prefixedIdentifier_constructorTearoff() async {
+    await assertNoDiagnostics(r'''
+/// Text [Future.delayed].
+class C {}
+''');
+  }
+
   test_prefixedIdentifier_importPrefix() async {
     await assertNoDiagnostics(r'''
 import 'dart:async' as async;
@@ -192,6 +192,22 @@ class C {}
 ''');
   }
 
+  test_prefixedIdentifier_instanceMember() async {
+    await assertNoDiagnostics(r'''
+/// Text [int.isEven].
+class C {}
+''');
+  }
+
+  test_prefixedIdentifier_instanceMember_onTypedef() async {
+    await assertNoDiagnostics(r'''
+typedef int2 = int;
+
+/// Text [int2.isEven].
+class C {}
+''');
+  }
+
   test_prefixedIdentifier_staticMethod() async {
     await assertNoDiagnostics(r'''
 /// Text [Future.wait].
@@ -214,6 +230,19 @@ class C {}
 ''');
   }
 
+  test_propertyAccess_onTypedef() async {
+    await assertNoDiagnostics(r'''
+import '' as self;
+class A {
+  int get x => 7;
+}
+typedef B = A;
+
+/// Text [self.B.x].
+class C {}
+''');
+  }
+
   test_this() async {
     await assertDiagnostics(
       r'''
@@ -234,6 +263,15 @@ class C {}
     );
   }
 
+  test_typeAlias() async {
+    await assertNoDiagnostics(r'''
+/// Text [Td].
+class C {}
+
+typedef Td = C;
+''');
+  }
+
   test_typeName() async {
     await assertNoDiagnostics(r'''
 /// Text [Future].