[_fe_analyzer_shared] Test late resolution of macro metadata

This delays the resolution of the identifier in metadata, such the
parsed annotation expression is initially unresolved and
`Expression.resolve` must be called in order to resolve it.

This execises the support for references to identifiers declare via
macros, which will initially occur as unresolved identifiers.

Change-Id: I4863ce950ded0b9d2c1744421d9751cddea6e80c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/391641
Reviewed-by: Konstantin Shcheglov <[email protected]>
Reviewed-by: Jens Johansen <[email protected]>

Author: johnniwinther

pkg/_fe_analyzer_shared/lib/src/testing/metadata_helper.dart

@@ -23,6 +23,32 @@ Expression unwrap(Expression expression) {
   return expression;
 }
 
+/// Creates a list containing structured and readable textual representation of
+/// the [unresolved] and [resolved] expressions.
+List<String> expressionsToText(
+    {required Expression unresolved, required Expression resolved}) {
+  List<String> list = [];
+  list.add('unresolved=${expressionToText(unwrap(unresolved))}');
+
+  // The identifiers in [expression] haven't been resolved, so
+  // we call [Expression.resolve] to convert the expression into
+  // its resolved equivalent.
+  Expression lateResolved = unresolved.resolve() ?? unresolved;
+
+  String earlyResolvedText = expressionToText(unwrap(resolved));
+  String lateResolvedText = expressionToText(unwrap(lateResolved));
+
+  // These should always be the same. If not we include both to
+  // signal the error.
+  if (earlyResolvedText == lateResolvedText) {
+    list.add('resolved=${earlyResolvedText}');
+  } else {
+    list.add('early-resolved=${earlyResolvedText}');
+    list.add('late-resolved=${lateResolvedText}');
+  }
+  return list;
+}
+
 /// Creates a structured and readable textual representation of [expression].
 String expressionToText(Expression expression) {
   Writer writer = new Writer();
@@ -308,10 +334,11 @@ class Writer {
       case DynamicTypeAnnotation():
         _write('dynamic');
       case InvalidTypeAnnotation():
-        _write('<<invalid-type-annotation>>');
+        _write('{invalid-type-annotation}');
       case UnresolvedTypeAnnotation():
-        _write('<<unresolved-type-annotation:');
+        _write('{unresolved-type-annotation:');
         _unresolvedToText(typeAnnotation.unresolved);
+        _write('}');
       case FunctionTypeAnnotation(:TypeAnnotation? returnType):
         if (returnType != null) {
           _typeAnnotationToText(returnType);