[_fe_analyzer_shared] Support extensions in macro metadata

Change-Id: I06d3eeab53d8f739ec75dc5795ce46b57ef6f05b
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/391400
Reviewed-by: Jens Johansen <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Johnni Winther <[email protected]>

Author: johnniwinther

pkg/_fe_analyzer_shared/lib/src/metadata/proto.dart

@@ -410,6 +410,56 @@ class ClassProto extends Proto {
   Proto? resolve() => null;
 }
 
+/// A [reference] to an extension
+///
+/// The [Proto] includes the [scope] of the extension, which is used to resolve
+/// access to static members on the extension.
+class ExtensionProto extends Proto {
+  final ExtensionReference reference;
+  final TypeDeclarationScope scope;
+
+  ExtensionProto(this.reference, this.scope);
+
+  @override
+  String toString() => 'ExtensionProto($reference)';
+
+  @override
+  Proto access(String? name) {
+    if (name == null) {
+      return this;
+    }
+    if (name == 'new') {
+      name = '';
+    }
+    return scope.lookup(name);
+  }
+
+  @override
+  Proto instantiate(List<TypeAnnotation>? typeArguments) {
+    return typeArguments != null
+        ? new InvalidInstantiationProto(this, typeArguments)
+        : this;
+  }
+
+  @override
+  Proto invoke(List<Argument>? arguments) {
+    return arguments != null
+        ? new InvalidInvocationProto(this, const [], arguments)
+        : this;
+  }
+
+  @override
+  Expression toExpression() {
+    return new InvalidExpression();
+  }
+
+  @override
+  TypeAnnotation toTypeAnnotation() => new InvalidTypeAnnotation();
+
+  @override
+  Proto? resolve() => null;
+}
+
 /// A [reference] to a class instantiated with [typeArguments].
 ///
 /// The [Proto] includes the [scope] of the class, which is used to resolve

pkg/_fe_analyzer_shared/lib/src/metadata/references.dart

@@ -52,6 +52,13 @@ abstract class TypedefReference extends Reference {
   String toString() => 'TypedefReference(${name})';
 }
 
+abstract class ExtensionReference extends Reference {
+  String get name;
+
+  @override
+  String toString() => 'ExtensionReference(${name})';
+}
+
 abstract class FunctionTypeParameterReference extends Reference {
   String get name;
 

pkg/_fe_analyzer_shared/lib/src/metadata/scope.dart

@@ -55,6 +55,26 @@ abstract base class BaseClassScope implements TypeDeclarationScope {
   }
 }
 
+/// Base implementation for creating a [TypeDeclarationScope] for an extension.
+abstract base class BaseExtensionScope implements TypeDeclarationScope {
+  ExtensionReference get extensionReference;
+
+  Proto createMemberProto<T>(List<TypeAnnotation>? typeArguments, String name,
+      T? member, Proto Function(T, String) memberToProto) {
+    if (typeArguments != null) {
+      return new UnresolvedAccess(
+          new InvalidInstantiationProto(
+              new ExtensionProto(extensionReference, this), typeArguments),
+          name);
+    } else if (member == null) {
+      return new UnresolvedAccess(
+          new ExtensionProto(extensionReference, this), name);
+    } else {
+      return memberToProto(member, name);
+    }
+  }
+}
+
 /// Base implementation for creating a [TypeDeclarationScope] for a typedef.
 abstract base class BaseTypedefScope implements TypeDeclarationScope {
   TypedefReference get typedefReference;

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

@@ -284,6 +284,8 @@ class Writer {
         _write(reference.name);
       case TypedefReference():
         _write(reference.name);
+      case ExtensionReference():
+        _write(reference.name);
       case FunctionTypeParameterReference():
         _write(reference.name);
     }
@@ -616,6 +618,10 @@ class Writer {
         _referenceToText(proto.reference);
         _typeArgumentsToText(proto.typeArguments);
         _write(')');
+      case ExtensionProto():
+        _write('ExtensionProto(');
+        _referenceToText(proto.reference);
+        _write(')');
       case TypedefProto():
         _write('TypedefProto(');
         _referenceToText(proto.reference);

pkg/_fe_analyzer_shared/test/metadata/data/extension/main.dart

@@ -0,0 +1,77 @@
+// Copyright (c) 2024, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:async';
+import 'main.dart' as self;
+
+class Helper {
+  const Helper(a);
+}
+
+extension Extension on int {
+  static const variable = 0;
+
+  static void method() {}
+
+  static void genericMethod<T>() {}
+}
+
+@Extension.variable
+/*member: extensionConstant1:
+StaticGet(variable)*/
+void extensionConstant1() {}
+
+@self.Extension.variable
+/*member: extensionConstant2:
+StaticGet(variable)*/
+void extensionConstant2() {}
+
+@Extension.unresolved
+/*member: extensionConstant3:
+UnresolvedExpression(UnresolvedAccess(
+  ExtensionProto(Extension).unresolved))*/
+void extensionConstant3() {}
+
+@self.Extension.unresolved
+/*member: extensionConstant4:
+UnresolvedExpression(UnresolvedAccess(
+  ExtensionProto(Extension).unresolved))*/
+void extensionConstant4() {}
+
+@Helper(Extension.method)
+/*member: extensionConstant5:
+FunctionTearOff(method)*/
+void extensionConstant5() {}
+
+@Helper(self.Extension.method)
+/*member: extensionConstant6:
+FunctionTearOff(method)*/
+void extensionConstant6() {}
+
+@Helper(Extension.genericMethod)
+/*member: extensionConstant7:
+FunctionTearOff(genericMethod)*/
+void extensionConstant7() {}
+
+@Helper(self.Extension.genericMethod)
+/*member: extensionConstant8:
+FunctionTearOff(genericMethod)*/
+void extensionConstant8() {}
+
+@Helper(Extension.genericMethod<int>)
+/*member: extensionConstant9:
+Instantiation(FunctionTearOff(genericMethod)<int>)*/
+void extensionConstant9() {}
+
+@Helper(self.Extension.genericMethod<int>)
+/*member: extensionConstant10:
+Instantiation(FunctionTearOff(genericMethod)<int>)*/
+void extensionConstant10() {}
+
+@Helper(Extension.unresolved<int>)
+/*member: extensionConstant11:
+UnresolvedExpression(UnresolvedInstantiate(
+  UnresolvedAccess(
+    ExtensionProto(Extension).unresolved)<int>))*/
+void extensionConstant11() {}

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

@@ -52,9 +52,13 @@ shared.Proto _elementToProto(Element element, String name) {
   } else if (element is TypeAliasElement) {
     var reference = _TypedefReference(element);
     return shared.TypedefProto(reference, _TypedefScope(element, reference));
+  } else if (element is ExtensionElement) {
+    var reference = _ExtensionReference(element);
+    return shared.ExtensionProto(
+        reference, _ExtensionScope(element, reference));
   }
 
-  // TODO(johnniwinther): Support extension and extension types.
+  // TODO(johnniwinther): Support extension types.
   throw UnsupportedError(
       "Unsupported element $element (${element.runtimeType}) for '$name'.");
 }
@@ -106,6 +110,32 @@ class _DynamicReference extends shared.TypeReference {
   String get name => 'dynamic';
 }
 
+class _ExtensionReference extends shared.ExtensionReference {
+  final ExtensionElement _element;
+
+  _ExtensionReference(this._element);
+
+  @override
+  String get name => _element.name!;
+}
+
+final class _ExtensionScope extends shared.BaseExtensionScope {
+  final ExtensionElement _extensionElement;
+
+  @override
+  final _ExtensionReference extensionReference;
+
+  _ExtensionScope(this._extensionElement, this.extensionReference);
+
+  @override
+  shared.Proto lookup(String name,
+      [List<shared.TypeAnnotation>? typeArguments]) {
+    Element? member = _extensionElement.augmented.getField(name);
+    member ??= _extensionElement.augmented.getMethod(name);
+    return createMemberProto(typeArguments, name, member, _elementToProto);
+  }
+}
+
 class _FunctionReference extends shared.FunctionReference {
   final ExecutableElement _element;
 

pkg/front_end/lib/src/kernel/macro/metadata.dart

@@ -59,8 +59,13 @@ shared.Proto builderToProto(Builder builder, String name) {
     shared.TypedefReference typedefReference = new TypedefReference(builder);
     return new shared.TypedefProto(
         typedefReference, new TypedefScope(builder, typedefReference));
+  } else if (builder is ExtensionBuilder) {
+    shared.ExtensionReference extensionReference =
+        new ExtensionReference(builder);
+    return new shared.ExtensionProto(
+        extensionReference, new ExtensionScope(builder, extensionReference));
   } else {
-    // TODO(johnniwinther): Support extension and extension types.
+    // TODO(johnniwinther): Support extension types.
     throw new UnsupportedError("Unsupported builder $builder for $name");
   }
 }
@@ -139,6 +144,22 @@ final class ClassScope extends shared.BaseClassScope {
   }
 }
 
+// Coverage-ignore(suite): Not run.
+final class ExtensionScope extends shared.BaseExtensionScope {
+  final ExtensionBuilder builder;
+  @override
+  final shared.ExtensionReference extensionReference;
+
+  ExtensionScope(this.builder, this.extensionReference);
+
+  @override
+  shared.Proto lookup(String name,
+      [List<shared.TypeAnnotation>? typeArguments]) {
+    Builder? member = builder.lookupLocalMember(name, setter: false);
+    return createMemberProto(typeArguments, name, member, builderToProto);
+  }
+}
+
 // Coverage-ignore(suite): Not run.
 final class TypedefScope extends shared.BaseTypedefScope {
   final TypeAliasBuilder builder;
@@ -243,6 +264,16 @@ class ClassReference extends shared.ClassReference {
   String get name => builder.name;
 }
 
+// Coverage-ignore(suite): Not run.
+class ExtensionReference extends shared.ExtensionReference {
+  final ExtensionBuilder builder;
+
+  ExtensionReference(this.builder);
+
+  @override
+  String get name => builder.name;
+}
+
 // Coverage-ignore(suite): Not run.
 class TypedefReference extends shared.TypedefReference {
   final TypeAliasBuilder builder;