Issue 46064. Support for metadata in aliased GenericFunctionType type / formal parameters.

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

Author: scheglov

pkg/analyzer/lib/src/dart/analysis/driver.dart

@@ -80,7 +80,7 @@ import 'package:meta/meta.dart';
 /// TODO(scheglov) Clean up the list of implicitly analyzed files.
 class AnalysisDriver implements AnalysisDriverGeneric {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 137;
+  static const int DATA_VERSION = 138;
 
   /// The length of the list returned by [_computeDeclaredVariablesSignature].
   static const int _declaredVariablesSignatureLength = 4;

pkg/analyzer/lib/src/summary2/bundle_reader.dart

@@ -1457,7 +1457,7 @@ class ResolutionReader {
     if (tag == AliasedElementTag.nothing) {
       return null;
     } else if (tag == AliasedElementTag.genericFunctionElement) {
-      var typeParameters = _readTypeParameters();
+      var typeParameters = _readTypeParameters(unitElement);
       var formalParameters = _readFormalParameters(unitElement);
       var returnType = readRequiredType();
 
@@ -1536,7 +1536,7 @@ class ResolutionReader {
       var kindIndex = _reader.readByte();
       var kind = _formalParameterKind(kindIndex);
       var isInitializingFormal = _reader.readBool();
-      var typeParameters = _readTypeParameters();
+      var typeParameters = _readTypeParameters(unitElement);
       var type = readRequiredType();
       var name = readStringReference();
       if (kind.isRequiredPositional) {
@@ -1577,7 +1577,7 @@ class ResolutionReader {
   /// TODO(scheglov) Optimize for write/read of types without type parameters.
   FunctionType _readFunctionType() {
     // TODO(scheglov) reuse for formal parameters
-    var typeParameters = _readTypeParameters();
+    var typeParameters = _readTypeParameters(null);
     var returnType = readRequiredType();
     var formalParameters = _readFormalParameters(null);
 
@@ -1666,7 +1666,9 @@ class ResolutionReader {
     return types;
   }
 
-  List<TypeParameterElementImpl> _readTypeParameters() {
+  List<TypeParameterElementImpl> _readTypeParameters(
+    CompilationUnitElementImpl? unitElement,
+  ) {
     var typeParameterCount = _reader.readUInt30();
     var typeParameters = List.generate(typeParameterCount, (_) {
       var name = readStringReference();
@@ -1677,6 +1679,9 @@ class ResolutionReader {
 
     for (var typeParameter in typeParameters) {
       typeParameter.bound = readType();
+      if (unitElement != null) {
+        typeParameter.metadata = _readAnnotationList(unitElement: unitElement);
+      }
     }
     return typeParameters;
   }

pkg/analyzer/lib/src/summary2/bundle_writer.dart

@@ -630,7 +630,7 @@ class ResolutionSink extends _SummaryDataWriter {
       _writeTypeParameters(element.typeParameters, () {
         _writeFormalParameters(element.parameters, withAnnotations: true);
         writeType(element.returnType);
-      });
+      }, withAnnotations: true);
     } else {
       throw UnimplementedError('${element.runtimeType}');
     }
@@ -665,7 +665,7 @@ class ResolutionSink extends _SummaryDataWriter {
           parameter.parameters,
           withAnnotations: withAnnotations,
         );
-      });
+      }, withAnnotations: withAnnotations);
       if (withAnnotations) {
         _writeAnnotationList(parameter.metadata);
       }
@@ -680,7 +680,7 @@ class ResolutionSink extends _SummaryDataWriter {
     _writeTypeParameters(type.typeFormals, () {
       writeType(type.returnType);
       _writeFormalParameters(type.parameters, withAnnotations: false);
-    });
+    }, withAnnotations: false);
     _writeNullabilitySuffix(type.nullabilitySuffix);
   }
 
@@ -736,8 +736,9 @@ class ResolutionSink extends _SummaryDataWriter {
 
   void _writeTypeParameters(
     List<TypeParameterElement> typeParameters,
-    void Function() f,
-  ) {
+    void Function() f, {
+    required bool withAnnotations,
+  }) {
     localElements.pushScope();
     localElements.declareAll(typeParameters);
     try {
@@ -747,6 +748,9 @@ class ResolutionSink extends _SummaryDataWriter {
       }
       for (var typeParameter in typeParameters) {
         writeType(typeParameter.bound);
+        if (withAnnotations) {
+          _writeAnnotationList(typeParameter.metadata);
+        }
       }
       f();
     } finally {

pkg/analyzer/test/src/summary/element_text.dart

@@ -1084,6 +1084,21 @@ class _ElementWriter {
     }
 
     buffer.writeln(';');
+
+    if (withFullyResolvedAst) {
+      _withIndent(() {
+        _writeResolvedMetadata(e.metadata);
+        _writeResolvedTypeParameters(e.typeParameters);
+        var aliasedElement = e.aliasedElement;
+        if (aliasedElement is GenericFunctionTypeElement) {
+          _writelnWithIndent('aliasedElement');
+          _withIndent(() {
+            _writeResolvedTypeParameters(aliasedElement.typeParameters);
+            _writeResolvedParameterElements(aliasedElement.parameters);
+          });
+        }
+      });
+    }
   }
 
   void writeTypeInferenceError(Element e) {
@@ -1319,6 +1334,37 @@ class _ElementWriter {
     );
   }
 
+  void _writeResolvedParameterElements(
+    List<ParameterElement> parameters, {
+    String enclosingNames = '',
+  }) {
+    if (parameters.isNotEmpty) {
+      _writelnWithIndent('parameters');
+      _withIndent(() {
+        var index = 0;
+        for (var formalParameter in parameters) {
+          var metadata = formalParameter.metadata;
+          var name = formalParameter.name;
+          if (name.isEmpty) {
+            name = '$index';
+          }
+          _writelnWithIndent(name);
+          _withIndent(() {
+            _writeResolvedMetadata(metadata);
+            var subParameters = formalParameter.parameters;
+            _withIndent(() {
+              _writeResolvedParameterElements(
+                subParameters,
+                enclosingNames: enclosingNames + name + '::',
+              );
+            });
+          });
+          index++;
+        }
+      });
+    }
+  }
+
   void _writeResolvedTypeParameters(List<TypeParameterElement> elements) {
     if (elements.isNotEmpty) {
       _writelnWithIndent('typeParameters');

pkg/analyzer/test/src/summary/resynthesize_common.dart

@@ -11054,6 +11054,96 @@ const int a;
         withFullyResolvedAst: true);
   }
 
+  test_metadata_inAliasedElement_formalParameter() async {
+    var library = await checkLibrary('''
+const a = 42;
+typedef F = void Function(@a int first)
+''');
+    checkElementText(
+        library,
+        r'''
+typedef F = void Function(int first);
+  aliasedElement
+    parameters
+      first
+        metadata
+          Annotation
+            element: self::@getter::a
+            name: SimpleIdentifier
+              staticElement: self::@getter::a
+              staticType: null
+              token: a
+const int a;
+  constantInitializer
+    IntegerLiteral
+      literal: 42
+      staticType: int
+''',
+        withFullyResolvedAst: true);
+  }
+
+  test_metadata_inAliasedElement_formalParameter2() async {
+    var library = await checkLibrary('''
+const a = 42;
+typedef F = void Function(int foo(@a int bar))
+''');
+    checkElementText(
+        library,
+        r'''
+typedef F = void Function(int Function(int) foo);
+  aliasedElement
+    parameters
+      foo
+          parameters
+            bar
+              metadata
+                Annotation
+                  element: self::@getter::a
+                  name: SimpleIdentifier
+                    staticElement: self::@getter::a
+                    staticType: null
+                    token: a
+const int a;
+  constantInitializer
+    IntegerLiteral
+      literal: 42
+      staticType: int
+''',
+        withFullyResolvedAst: true);
+  }
+
+  test_metadata_inAliasedElement_typeParameter() async {
+    var library = await checkLibrary('''
+const a = 42;
+typedef F = void Function<@a T>(int first)
+''');
+    checkElementText(
+        library,
+        r'''
+typedef F = void Function(int first);
+  aliasedElement
+    typeParameters
+      T
+        bound: null
+        defaultType: null
+        metadata
+          Annotation
+            element: self::@getter::a
+            name: SimpleIdentifier
+              staticElement: self::@getter::a
+              staticType: null
+              token: a
+    parameters
+      first
+const int a;
+  constantInitializer
+    IntegerLiteral
+      literal: 42
+      staticType: int
+''',
+        withFullyResolvedAst: true);
+  }
+
   test_metadata_invalid_classDeclaration() async {
     var library = await checkLibrary('f(_) {} @f(42) class C {}');
     checkElementText(library, r'''