Version 3.7.0-68.0.dev

Merge 253e715 into dev

DEPS

@@ -54,7 +54,7 @@ vars = {
 
   # co19 is a cipd package automatically generated for each co19 commit.
   # Use tests/co19/update.sh to update this hash.
-  "co19_rev": "f29a4cb47ad3de25d2cebc274a84f7e1541d75ab",
+  "co19_rev": "5582f300f30244ffd6e363761315d400cc37a023",
 
   # The internal benchmarks to use. See go/dart-benchmarks-internal
   "benchmarks_internal_rev": "3bd6bc6d207dfb7cf687537e819863cf9a8f2470",

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

@@ -622,6 +622,112 @@ class GenericEnumProto extends Proto {
   }
 }
 
+/// A [reference] to a mixin
+///
+/// The [Proto] includes the [scope] of the mixin, which is used to resolve
+/// access to static members on the mixin.
+class MixinProto extends Proto {
+  final MixinReference reference;
+  final TypeDeclarationScope scope;
+
+  MixinProto(this.reference, this.scope);
+
+  @override
+  String toString() => 'MixinProto($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 GenericMixinProto(reference, scope, typeArguments)
+        : this;
+  }
+
+  @override
+  Proto invoke(List<Argument>? arguments) {
+    return arguments != null
+        ? new InvalidInvocationProto(this, const [], arguments)
+        : this;
+  }
+
+  @override
+  Expression toExpression() {
+    return new TypeLiteral(toTypeAnnotation());
+  }
+
+  @override
+  TypeAnnotation toTypeAnnotation() => new NamedTypeAnnotation(reference);
+
+  @override
+  Proto? resolve() => null;
+}
+
+/// A [reference] to an enum instantiated with [typeArguments].
+///
+/// The [Proto] includes the [scope] of the enum, which is used to resolve
+/// access to constructors on the enum.
+class GenericMixinProto extends Proto {
+  final MixinReference reference;
+  final TypeDeclarationScope scope;
+  final List<TypeAnnotation> typeArguments;
+
+  GenericMixinProto(this.reference, this.scope, this.typeArguments);
+
+  @override
+  String toString() => 'GenericMixinProto($reference,$typeArguments)';
+
+  @override
+  Proto access(String? name) {
+    if (name == null) {
+      return this;
+    }
+    if (name == 'new') {
+      name = '';
+    }
+    return scope.lookup(name, typeArguments);
+  }
+
+  @override
+  Proto instantiate(List<TypeAnnotation>? typeArguments) {
+    return typeArguments != null
+        ? throw new UnimplementedError('$this.instantiate')
+        : this;
+  }
+
+  @override
+  Proto invoke(List<Argument>? arguments) {
+    return arguments != null ? access('new').invoke(arguments) : this;
+  }
+
+  @override
+  Expression toExpression() {
+    return new TypeLiteral(toTypeAnnotation());
+  }
+
+  @override
+  TypeAnnotation toTypeAnnotation() =>
+      new NamedTypeAnnotation(reference, typeArguments);
+
+  @override
+  Proto? resolve() {
+    List<TypeAnnotation>? newTypeArguments =
+    typeArguments.resolve((a) => a.resolve());
+    return newTypeArguments == null
+        ? null
+        : new GenericMixinProto(reference, scope, newTypeArguments);
+  }
+}
+
 /// A [reference] to an extension type.
 ///
 /// The [Proto] includes the [scope] of the extension type, which is used to

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

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

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

@@ -137,6 +137,30 @@ abstract base class BaseEnumScope implements TypeDeclarationScope {
   }
 }
 
+/// Base implementation for creating a [TypeDeclarationScope] for a mixin.
+abstract base class BaseMixinScope implements TypeDeclarationScope {
+  MixinReference get mixinReference;
+
+  Proto createMemberProto<T>(List<TypeAnnotation>? typeArguments, String name,
+      T? member, Proto Function(T, String) memberToProto) {
+    if (member == null) {
+      if (typeArguments != null) {
+        return new UnresolvedAccess(
+            new GenericMixinProto(mixinReference, this, typeArguments), name);
+      } else {
+        return new UnresolvedAccess(new MixinProto(mixinReference, this), name);
+      }
+    } else {
+      if (typeArguments != null) {
+        return new InvalidAccessProto(
+            new GenericMixinProto(mixinReference, this, typeArguments), 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

@@ -316,6 +316,8 @@ class Writer {
         _write(reference.name);
       case EnumReference():
         _write(reference.name);
+      case MixinReference():
+        _write(reference.name);
       case FunctionTypeParameterReference():
         _write(reference.name);
     }
@@ -658,6 +660,15 @@ class Writer {
         _referenceToText(proto.reference);
         _typeArgumentsToText(proto.typeArguments);
         _write(')');
+      case MixinProto():
+        _write('MixinProto(');
+        _referenceToText(proto.reference);
+        _write(')');
+      case GenericMixinProto():
+        _write('GenericMixinProto(');
+        _referenceToText(proto.reference);
+        _typeArgumentsToText(proto.typeArguments);
+        _write(')');
       case ExtensionProto():
         _write('ExtensionProto(');
         _referenceToText(proto.reference);

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

@@ -0,0 +1,191 @@
+// 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);
+}
+
+mixin Mixin {
+  static const int variable = 42;
+  static void method() {}
+  static void genericMethod<T>() {}
+}
+
+mixin GenericMixin<T> {}
+
+@Mixin.variable
+/*member: mixinConstant1:
+unresolved=UnresolvedExpression(UnresolvedAccess(
+  UnresolvedIdentifier(Mixin).variable))
+resolved=StaticGet(variable)*/
+void mixinConstant1() {}
+
+@self.Mixin.variable
+/*member: mixinConstant2:
+unresolved=UnresolvedExpression(UnresolvedAccess(
+  UnresolvedAccess(
+    UnresolvedIdentifier(self).Mixin).variable))
+resolved=StaticGet(variable)*/
+void mixinConstant2() {}
+
+@Helper(Mixin)
+/*member: mixinConstant3:
+unresolved=UnresolvedExpression(UnresolvedInvoke(
+  UnresolvedIdentifier(Helper)
+  (UnresolvedExpression(UnresolvedIdentifier(Mixin)))))
+resolved=TypeLiteral(Mixin)*/
+void mixinConstant3() {}
+
+@Helper(self.Mixin)
+/*member: mixinConstant4:
+unresolved=UnresolvedExpression(UnresolvedInvoke(
+  UnresolvedIdentifier(Helper)
+  (UnresolvedExpression(UnresolvedAccess(
+    UnresolvedIdentifier(self).Mixin)))))
+resolved=TypeLiteral(Mixin)*/
+void mixinConstant4() {}
+
+@Helper(Mixin.method)
+/*member: mixinConstant5:
+unresolved=UnresolvedExpression(UnresolvedInvoke(
+  UnresolvedIdentifier(Helper)
+  (UnresolvedExpression(UnresolvedAccess(
+    UnresolvedIdentifier(Mixin).method)))))
+resolved=FunctionTearOff(method)*/
+void mixinConstant5() {}
+
+@Helper(self.Mixin.method)
+/*member: mixinConstant6:
+unresolved=UnresolvedExpression(UnresolvedInvoke(
+  UnresolvedIdentifier(Helper)
+  (UnresolvedExpression(UnresolvedAccess(
+    UnresolvedAccess(
+      UnresolvedIdentifier(self).Mixin).method)))))
+resolved=FunctionTearOff(method)*/
+void mixinConstant6() {}
+
+@Helper(Mixin.genericMethod)
+/*member: mixinConstant7:
+unresolved=UnresolvedExpression(UnresolvedInvoke(
+  UnresolvedIdentifier(Helper)
+  (UnresolvedExpression(UnresolvedAccess(
+    UnresolvedIdentifier(Mixin).genericMethod)))))
+resolved=FunctionTearOff(genericMethod)*/
+void mixinConstant7() {}
+
+@Helper(self.Mixin.genericMethod)
+/*member: mixinConstant8:
+unresolved=UnresolvedExpression(UnresolvedInvoke(
+  UnresolvedIdentifier(Helper)
+  (UnresolvedExpression(UnresolvedAccess(
+    UnresolvedAccess(
+      UnresolvedIdentifier(self).Mixin).genericMethod)))))
+resolved=FunctionTearOff(genericMethod)*/
+void mixinConstant8() {}
+
+@Helper(Mixin.genericMethod<int>)
+/*member: mixinConstant9:
+unresolved=UnresolvedExpression(UnresolvedInvoke(
+  UnresolvedIdentifier(Helper)
+  (UnresolvedExpression(UnresolvedInstantiate(
+    UnresolvedAccess(
+      UnresolvedIdentifier(Mixin).genericMethod)<{unresolved-type-annotation:UnresolvedIdentifier(int)}>)))))
+resolved=Instantiation(FunctionTearOff(genericMethod)<int>)*/
+void mixinConstant9() {}
+
+@Helper(self.Mixin.genericMethod<int>)
+/*member: mixinConstant10:
+unresolved=UnresolvedExpression(UnresolvedInvoke(
+  UnresolvedIdentifier(Helper)
+  (UnresolvedExpression(UnresolvedInstantiate(
+    UnresolvedAccess(
+      UnresolvedAccess(
+        UnresolvedIdentifier(self).Mixin).genericMethod)<{unresolved-type-annotation:UnresolvedIdentifier(int)}>)))))
+resolved=Instantiation(FunctionTearOff(genericMethod)<int>)*/
+void mixinConstant10() {}
+
+@Helper(GenericMixin)
+/*member: mixinConstant11:
+unresolved=UnresolvedExpression(UnresolvedInvoke(
+  UnresolvedIdentifier(Helper)
+  (UnresolvedExpression(UnresolvedIdentifier(GenericMixin)))))
+resolved=TypeLiteral(GenericMixin)*/
+void mixinConstant11() {}
+
+@Helper(self.GenericMixin)
+/*member: mixinConstant12:
+unresolved=UnresolvedExpression(UnresolvedInvoke(
+  UnresolvedIdentifier(Helper)
+  (UnresolvedExpression(UnresolvedAccess(
+    UnresolvedIdentifier(self).GenericMixin)))))
+resolved=TypeLiteral(GenericMixin)*/
+void mixinConstant12() {}
+
+@Helper(GenericMixin<bool>)
+/*member: mixinConstant13:
+unresolved=UnresolvedExpression(UnresolvedInvoke(
+  UnresolvedIdentifier(Helper)
+  (UnresolvedExpression(UnresolvedInstantiate(
+    UnresolvedIdentifier(GenericMixin)<{unresolved-type-annotation:UnresolvedIdentifier(bool)}>)))))
+resolved=TypeLiteral(GenericMixin<bool>)*/
+void mixinConstant13() {}
+
+@Helper(self.GenericMixin<double>)
+/*member: mixinConstant14:
+unresolved=UnresolvedExpression(UnresolvedInvoke(
+  UnresolvedIdentifier(Helper)
+  (UnresolvedExpression(UnresolvedInstantiate(
+    UnresolvedAccess(
+      UnresolvedIdentifier(self).GenericMixin)<{unresolved-type-annotation:UnresolvedIdentifier(double)}>)))))
+resolved=TypeLiteral(GenericMixin<double>)*/
+void mixinConstant14() {}
+
+@Helper(Mixin.unresolved)
+/*member: mixinConstant15:
+unresolved=UnresolvedExpression(UnresolvedInvoke(
+  UnresolvedIdentifier(Helper)
+  (UnresolvedExpression(UnresolvedAccess(
+    UnresolvedIdentifier(Mixin).unresolved)))))
+resolved=UnresolvedExpression(UnresolvedAccess(
+  MixinProto(Mixin).unresolved))*/
+void mixinConstant15() {}
+
+@Helper(self.Mixin.unresolved)
+/*member: mixinConstant16:
+unresolved=UnresolvedExpression(UnresolvedInvoke(
+  UnresolvedIdentifier(Helper)
+  (UnresolvedExpression(UnresolvedAccess(
+    UnresolvedAccess(
+      UnresolvedIdentifier(self).Mixin).unresolved)))))
+resolved=UnresolvedExpression(UnresolvedAccess(
+  MixinProto(Mixin).unresolved))*/
+void mixinConstant16() {}
+
+@Helper(Mixin.unresolved<int>)
+/*member: mixinConstant17:
+unresolved=UnresolvedExpression(UnresolvedInvoke(
+  UnresolvedIdentifier(Helper)
+  (UnresolvedExpression(UnresolvedInstantiate(
+    UnresolvedAccess(
+      UnresolvedIdentifier(Mixin).unresolved)<{unresolved-type-annotation:UnresolvedIdentifier(int)}>)))))
+resolved=UnresolvedExpression(UnresolvedInstantiate(
+  UnresolvedAccess(
+    MixinProto(Mixin).unresolved)<int>))*/
+void mixinConstant17() {}
+
+@Helper(self.Mixin.unresolved<int>)
+/*member: mixinConstant18:
+unresolved=UnresolvedExpression(UnresolvedInvoke(
+  UnresolvedIdentifier(Helper)
+  (UnresolvedExpression(UnresolvedInstantiate(
+    UnresolvedAccess(
+      UnresolvedAccess(
+        UnresolvedIdentifier(self).Mixin).unresolved)<{unresolved-type-annotation:UnresolvedIdentifier(int)}>)))))
+resolved=UnresolvedExpression(UnresolvedInstantiate(
+  UnresolvedAccess(
+    MixinProto(Mixin).unresolved)<int>))*/
+void mixinConstant18() {}